Packages

List of available packages. This page is mined to populate clib-search(1).

String manipulation

• clibs/buffer - tiny c-string library
• nami-doc/trim.c - trim a string, in place
• nami-doc/strlen.c - get a string's length
• jwerle/strsplit.h - Split a string into a char array by a given delimiter
• jwerle/chfreq.c - Compute character frequency in a string
• hkjels/slug.c - Create slug from a given string.
• stephenmathieson/case.c - string case conversion
• stephenmathieson/occurrences.c - Count occurrences in a string
• stephenmathieson/path-join.c - join a path
• stephenmathieson/path-normalize.c - normalize a path
• jb55/extname.c - get the extension of a file from a path
• mofosyne/extractFilePathComponents.c - Extract Directory, Filename And Extension from filepath
• stephenmathieson/rot13.c - Simple ROT13
• stephenmathieson/str-ends-with.c - Check if a string ends with another string
• stephenmathieson/str-flatten.c - Flatten a char array
• stephenmathieson/str-replace.c - string replacement
• stephenmathieson/str-starts-with.c - Check if a string starts with another string
• stephenmathieson/substr.c - Get a substring of a string
• stephenmathieson/trim.c - string trim with left and right support
• dhobsd/vstring - A simple string building API for C
• chrisdew/sds - Antirez's Simple Dynamic Strings library
• michaelrhodes/path-basename.c - Find the last portion of a path. Similar to Node’s path.basename method.
• movesmyers/str-truncate.c - Simple string truncation
• clibs/wildcardcmp - Simple wildcard string comparison for C
• Neved4/asprintf - Robust, portable asprintf, vasprintf implementation
• littlstar/asprintf.c - asprintf() implementation
• clibs/strndup - Safe implementation of strndup
• clibs/strdup - Safe implementation of strdup
• mattn/wcwidth - Determine columns needed for a wide character
• TingPing/ustring - Utils for safely handling utf8 strings.
• movesmyers/char-indices.c - Get an array of indices where a character exists in a string
• wooorm/stmr.c - Porter Stemmer algorithm
• gioyik/buffer-libc - Buffer C lib
• littlstar/trim.cc - C++ std::string trim util
• wooorm/levenshtein.c - Levenshtein’s string edit distance algorithm
• lib-x/xstr - A simple public domain string library
• aperezdc/dbuf - Resizable data buffer.
• promsize/abortf - Printing and formatting versions of abort
• promsize/msprintf - Allocating versions of sprintf
• kokke/tiny-regex-c - Small portable regex
• mofosyne/strtok_escaped.c - Tokenise a string from a single char deliminator. This is an alternative to strtok but with escaped character support for deliminating a string with a single char (e.g. csv or psv)
• goodcleanfun/utf8proc - clib pointer to utf8proc for processing UTF-8 data, unicode normalization, etc.
• goodcleanfun/char_array - safe, dynamic character arrays with string join operations
• goodcleanfun/cstring_array - stores many C NUL-terminated strings as one contiguous, dynamic/resizable array or characters with index pointers, good for e.g. tokenized strings.
• goodcleanfun/semiformal - a fast tokenizer/lexer for text using unicode.org's TR-29 segmentation rules, built with re2c
• c-sdk/strnstr - strnstr(3) implementation polyfill.
• goodcleanfun/simd_utf8 - fast UTF-8 validation using the range algorithm with AVX2 instructions, made cross-platform via SIMDe
• goodcleanfun/simd_transcoding - Transcoding UTF-8/Latin-1/UTF-16/UTF-32 with SIMDe AVX2 functions, port of simdutf AVX2 transcoding routines to C, with a safer API.

Utilities

• clibs/rgba - rgba color string parser
• clibs/unlikely - gcc branch prediction macros
• aperezdc/cflag - Non-allocating command line flag parser
• clibs/commander - expressive argument parser
• clibs/flag - Go style flag parsing
• clibs/ms - millisecond parser / formatter util
• clibs/bytes - byte-length parser / formatter util
• clibs/term - terminal utilities
• clibs/inih - INI parser
• jb55/rotate-bits.h - bitwise rotations
• jwerle/url.h - Parse URLs in C much like Node's url module.
• doches/progressbar - A library for displaying command-line progress bars
• jwerle/progress.h - Progress display lib for c
• jwerle/repl.h - Create a repl with eval/print/error hooks with given stdin, stdout, and stderr streams
• jwerle/getch.c - getch() implementation
• jwerle/usleep.h - usleep implementation using poll() or select()
• jwerle/libbacon - A C implementation of the Baconian Cipher ! BACON
• jwerle/libbeaufort - A C implementation of the Beaufort Cipher
• madmurphy/libconfini - Yet another INI parser
• stephenmathieson/is-email.c - Loosely validate an email address
• thlorenz/gumbo-parser.c - HTML5 parser
• thlorenz/log.h - Minimal yet colorful logging lib
• sciascid/tree - convenient wrapper around BSD sys/tree.h.
• clehner/chains - Markov chains
• Constellation/console-colors.c - Write formatted string to console with colors
• stephenmathieson/expand-braces.c - Simple shell-like brace expansion
• stephenmathieson/wiki-registry.c - Turn a GitHub wiki page into a package registry
• xythobuz/serial - POSIX serial port interface with optional flow control support.
• lukedeo/cmd-parser - A Lightweight, header-only commandline parser
• clibs/mt19937ar - Mersenne Twister random number generator
• willemt/config-re - Data structure allows your program to be configured
• brendanashworth/genpassword.c - Random password generating library
• clibs/dumpasn1 - Displays contents of ASN.1 encoded data
• orangeduck/LuaAutoC - Automagically use C Functions and Structs with the Lua API
• Gioyik/color-sh - Display colors on your terminal
• Gioyik/c_printf - Color C lib for printf
• Gioyik/slim_color - Ultra simple C lib to output color
• nsf/termbox - Powerful but simple library for writing text-based user interfaces
• noporpoise/sort_r - Portable re-entrant qsort (qsort_r / qsort_s)
• kdmurray91/clogged - Configurable and pretty logging library
• Isty001/mem-pool - Dynamic memory pool implementation, for reusable fixed, or variable sized memory blocks, using pthread mutex locks
• alebcay/metric - Macros for converting between metric and customary units
• Isty001/dotenv-c - .env loader for C
• daddinuz/liblogger - DEPRECATED A logging library written in ANSI C
• daddinuz/logger - A logging library written in C99
• ararslan/termcolor-c - Header-only ANSI C library for colored text output
• daddinuz/arena - Region based, expandable, memory allocator
• abranhe/mergesort.c - Merge sort algorithm implementation
• bonedaddy/ulog - Lightweight and threadsafe logger with color coded text and optional file logging
• aperezdc/clog - Simple logger which does not allocate memory and can be configured at runtime using environment variables.
• clibs/linenoise - A minimal, zero-config, BSD licensed, readline replacement used in Redis, MongoDB, and Android.
• exbotanical/lib.thread - Bespoke POSIX threads, mutexes, wait queues, thread pools, and semaphores for the C programming language.
• exbotanical/lib.chron - Timers, hierarchical wheels, and event scheduling utilities.
• promsize/memalign - Standard-like functions for pointer alignment
• exbotanical/libutil - JavaScript-inspired utilities for arrays and buffers.
• phoenixpinpoint/Surveyor - A dependency build management tool for clib
• mofosyne/sexp_prettify - Prettifies S-expressions (Based On KiCAD formatting)
• rswinkle/clnk - single-header library to extract the path from windows shortcut files (.lnk files)
• goodcleanfun/sort - Generic sort algorithms from klib including heapsort, introsort, ksmall, mergesort, radixsort and random shuffle
• goodcleanfun/bit_utils - Cross-platform popcount/ctz/clz using C11 _Generic for different sizes
• goodcleanfun/geohash - efficient and correct implementation of geohash algorithm based on skeeto/geohash with a few improvements and a function to get bounds for a given geohash
• goodcleanfun/random - fast, non-cryptographic random number generation using the xoshiro256++ for ints and xoshiro256+ for floats family. Includes the SplitMix64 seed generator and a cross-platform function get OS randomness from either /dev/urandom if available or address-space randomization if not.
• mofosyne/sensor_smoother.c - Smoothing filter intended for sensors in embedded applications
• goodcleanfun/likely cross-platform branch prediction macros
• goodcleanfun/aligned cross-platform aligned malloc/free and an aligned realloc implementation for dynamic structures
• goodcleanfun/pointer_tag utilities for pointer tagging/untagging using the least significant bits
• goodcleanfun/cpu_relax cross-platform intrinsics/inline Assembly for a hardware pause/NOP, used to minimize busy waiting in spinlocks and other lock-free contexts

Data structure

• jmi2k/disjoint.h - disjoint types (aka sum types)
• yrmt/ArrayList - doubly linked list based on BSD TAILQ
• clibs/hash - hash library built on zhash
• clibs/list - simple doubly linked list
• clibs/red-black-tree - Generic red-black tree library (by Julienne Walker).
• thlorenz/sync-stream.c - synchronous stream implementation
• troydhanson/uthash - C macros for hash tables and more
• willemt/cbuffer - circular buffer
• willemt/bipbuffer - circular buffer alternative
• willemt/heap - heap priority queue
• willemt/pseudolru - pseudo least recently used cache
• willemt/bag - data structure which only has put and randomised take operations
• willemt/bitfield - easily get and set bits in a bitfield
• willemt/array-avl-tree - self balancing tree
• willemt/linked-list-hashmap - hashmap that uses linked lists for managing collisions
• willemt/quadratic-probing-hashmap - hashmap that uses quadratic probing (open addressing) for managing collisions
• DavidLeeds/hashmap - templated and type-safe hashmap using open addressing and linear probing for collision resolution.
• rxi/vec - dynamic array
• jlcordeiro/cmap - map with string keys
• willemt/skiplist - Dictionary implemented through a skiplist
• willemt/linked-list-queue - Queue using a linked list
• willemt/meanqueue - An integer queue that calculates mean in O(1)
• willemt/chunkybar - Data structure that efficiently represents multi-piece progress bars
• willemt/farraylist - An arraylist that doesn't shift items so you can have "holes" between slots
• jonathanmarvens/hopscotch - A generic concurrent skip list library.
• mbucc/cqueue - OpenBSD's queue(3): linked lists and queues.
• clibs/lmdb - Symas Lightning Memory-Mapped Database (LMDB)
• willemt/arrayqueue - Queue implemented using an array
• AjayMT/dict.c - Simple dictionary implemented through a linked list
• AjayMT/list.c - Simple linked list
• skeeto/lstack - A lock-free stack using C11's new stdatomic.h features
• clehner/ll.c - Transparent linked lists
• kellydunn/libkld - Personal implementations of common datastructures. (List, Vector, Graph, Matrix, Tree, etc)
• willemt/duraqueue - Queue built to be durable under failure
• Gioyik/mapc - C lib for mapping
• neylsongularte/simple-linked-list-c - Linked list implementation
• htmk/Fat-Array - Dynamic arbitrary typed array using fat pointers and macros.
• laserswald/dlist - Type safe double linked list in the style of BSD's queue.h
• catb0t/sparse - Sparse arrays implemented by run-length-encoding regions of zeroes
• arablocks/flat-tree.c - A series of functions to map a binary tree to a list ported from flat-tree.
• jwerle/libmerkle - A C99 library for generating Merkle trees.
• rikvdh/zabuffer - A Zero-allocation buffer handling library for low-memory applications.
• rikvdh/zringbuf - A Zero-allocation ring-buffer library for low-memory applications.
• robusgauli/cvector - A Generic dynamic vector implementation with Iterator addon.
• robusgauli/cset - Type safe, Generic & Fast as F**K Set Data structure (uses XXHash).
• 4thel00z/env.h - Utilities to nicely interact with the environment variables.
• exbotanical/lib.cartilage - A library of various linked list data structures.
• exbotanical/lib.envoy - Thread-safe notification chains.
• goodcleanfun/array - Generic, dynamic arrays
• goodcleanfun/heap - Generic min/max heap based on a dynamic array
• goodcleanfun/circular_buffer - Generic, growable circular buffer implementation for deques
• goodcleanfun/memory_pool - Generic, growable memory pool of fixed-sized objects (tree nodes, etc.). Includes thread-safe, lock-free implementation using C11 atomics and a single test-and-test-and-set spinlock (using trylock) once per block allocation.
• goodcleanfun/binary_tree - General functions for making various kinds of binary trees
• goodcleanfun/avl_tree - AVL tree using a memory pool
• goodcleanfun/btree - efficient B+-tree implementation using memory pool
• goodcleanfun/weight_balanced_tree - Weight-balanced tree using a memory pool
• goodcleanfun/red_black_tree - Red-black tree using a memory pool
• goodcleanfun/skip_list - Skip list, randomized with an expected O(log n) for search/insert/delete. Uses memory pool for nodes and O(1) level generation from Skip Lists Done Right to reduce random coin flips. Includes a lock-free concurrent version.
• goodcleanfun/splay_tree - Splay tree, an adaptive binary search tree with query time proportional to the entropy of access patterns, using a memory pool
• goodcleanfun/matrix - Generic dense matrix operations including BLAS
• goodcleanfun/sparse_matrix - Sparse matrix stored in CSR/CSC format, including efficient sparse matrix-matrix multiply
• phoenixpinpoint/phoenixpinpoint - A List, Stack and, Queue library based on a doubly linked list
• goodcleanfun/weighted_sum_interval_tree - A dynamic, generic interval tree which keeps track of a set of intervals and evaluates the sum of all intervals containing a query point.
• goodcleanfun/max_interval_tree - Max-interval tree finds for a set of weighted intervals and a given query key, the max weight for the interval containing that key as well as maintaining a constant-time global maximum.
• mofosyne/cbuff.h - Malloc free, minimum overhead implementation of a circular buffer. Static inlined handlers for speed and ease of usage in various projects. Both index and pointer approach is provided.
• goodcleanfun/stack - Generic lock-free stack using a singly linked list with a memory pool for nodes. Includes thread-safe mode using atomics/compare-and-swap.
• goodcleanfun/khash - clib pointer to efficient hashtable implementation in klib
• goodcleanfun/set - Generic set container with intersection/union/difference, etc. built on khash
• goodcleanfun/dict - Generic dictionary built on khash
• goodcleanfun/concurrent_array - concurrent/thread-safe, generic, dynamic (push-only), contiguous array using a read-write spinlock and C11 atomics to ensure unique indices for each push or extend.

Parsing

• clibs/logfmt - fast logfmt parser.
• clibs/jsmn - JSON parser.
• orangeduck/mpc - Parser Combinator Library for C
• willemt/torrent-reader - Read torrent files
• mbucc/js0n - Parse JSON.
• jb55/field-range-parser.c - Parse field ranges (like cut)
• jb55/querystring.c - Querystring parser
• jb55/is_number.c - Test a string to see if it is a number
• brendanashworth/http-parser - http request/response parser for c
• h2non/semver.c - Semver 2.0 parser and render written in ANSI C
• kgabis/parson - Lightweight JSON library written in C.
• tay10r/mini-make - Miniature Makefile parser, written in C.
• septag/sjson - Lightweight single-file JSON library, written in C.
• rikvdh/matching - String-based parser based on matching strings for interpreting and handling string-based interfaces.
• hyperrealm/libconfig - Lightweight fully reentrant configuration parsing library well suited to memory-constrained systems.
• likle/cargs - A lightweight cross-platform getopt alternative that works on Linux, Windows and macOS. Command line argument parser library for C/C++. Can be used to parse argv and argc parameters.
• phoenixpinpoint/md4c-clib - Markdown Parser and HTML Generator for C. Ported from github.com/mity.
• mofosyne/minimal-multipart-form-data-parser-c - Minimal multipart/form-data Parser in C. Handles only one file, no validation. Targeting embedded systems, so aiming for small code size over speed or features.
• mofosyne/libyuarel - Simple C library for parsing URLs with zero-copy and no mallocs, including querystring.
• mofosyne/kv_get_value.c - Simple ANSI C Key Value String Parser. Reads entire buffer/file to locate a specific key and return a value string. Good for small projects not caring about speed.
• mofosyne/kv_parse.c - Composible Key Value Parser C library for parsing key value strings with zero-copy and no mallocs. (Can support INI style config files)
• aperezdc/sixpack - Small HiPack parser, may be configured to avoid allocations and target embedded devices.
• Darkcat5501/tomlc99 - TOML parser C99 compliant.

Encoding/Decoding

• clibs/rle - Run-length encoding
• clibs/snappy - Snappy codec
• littlstar/uri.c - URI Component encoder/decoder
• mbucc/chtmlescape - HTML escape the characters '<', '>', '&', and '"'
• littlstar/b64.c - Base64 encode/decode
• jwerle/libutf8 - A whatwg compliant UTF8 encoding and decoding library
• willemt/bitstream - Let me write out bits to a stream
• willemt/fe - Flip the endianess of integers
• mikepb/endian.h - Portable endian conversion functions for C
• mattn/locale-string - Convert between locale string and utf-8 string
• georgy7/zlib - A massively spiffy yet delicately unobtrusive compression library.
• lemire/simdcomp - A simple C library for compressing lists of integers
• powturbo/TurboPFor - Fastest Integer Compression + Direct Access w/o decompression
• pepaslabs/hexify.c - Convert binary data into a hexidecimal string
• aperezdc/ulid-c - Create and encode ULIDs, Universal Lexicographically-sortable Identifiers.
• jwerle/libsleepfile - A C99 library for interacting with SLEEP file storage.
• sorribas/varint.c - C library to encode/decode protobuf-style varint.
• goodcleanfun/byte_order - read/write numeric types specifying endianness
• goodcleanfun/lex_order - convert numeric types into binary-comparable representations that sort lexicographically
• goodcleanfun/byte_struct - a dynamic struct format (similar to Python's struct.pack/struct.unpack but with arrays and lexicographic sorting) useful for compound keys in trees/tries, prefix compression.
• mofosyne/char-utils.h - small C utility library macros and functions for char handling. e.g. conversion or checks for hex, digits and ascii values. Such as hex char to int and int to hex char.

Filesystem

• jwerle/fs.c - File system API much like Node's fs module
• stephenmathieson/mkdirp.c - mkdir -p
• stephenmathieson/rimraf.c - rm -rf
• willemt/file2str - reads a file and returns contents as a string
• willemt/stubfile - for managing the creation of files where the content of the files will be written to randomly
• stephenmathieson/tempdir.c - An implementation of Python's tempfile.tempdir algorithm
• willemt/pidfile - Create a pidfile
• cxong/tinydir - Lightweight, portable and easy to integrate C directory and file reader
• Isty001/copy - Copies files, directories recursively
• clibs/which - Locate executable via $PATH or given string
• likle/cwalk - Path library for C/C++. Cross-Platform for Windows, MacOS and Linux. Supports UNIX and Windows path styles on those platforms.
• goodcleanfun/file_utils - endian-agnostic file I/O for numeric types and arrays
• goodcleanfun/mapped_file - cross-platform mapped file (mmap) implementation
• rswinkle/file_browser - single-header cross-platform file browsing for any UI system

Hashing

• Cyan4973/xxHash - Extremely fast non-cryptographic hash algorithm
• jwerle/murmurhash.c - MurmurHash3 general hash bashed lookup function implementation
• clibs/sha1 - sha1 hash algorithm
• jb55/sha256.c - sha256 hash algorithm
• aperezdc/hmac-sha256 - hmac-sha256 message authentication algorithm
• pepaslabs/rhash_md5.c - md5 hash algorithm (from RHash)
• zackehh/siphash-c - SipHash hash algorithm
• catb0t/fnv-hash - Fowler/Noll/Vo non-cryptographic hash algorithms
• exbotanical/libhash - A simple open-addressed, double-hashed hash table.

Encryption

• veqtrus/vial_aes - AES block cipher with ECB, CBC, CTR, EAX encryption/ decryption and CMAC authentication

Net

• aisk/libae - Async event loop library extract from from redis
• jb55/anet.c - Basic TCP socket stuff made a bit less boring
• willemt/raft - C implementation of the Raft consensus protocol
• willemt/tracker-client - Connect to a bittorrent tracker
• willemt/pwp - A Bittorrent peer wire protocol implementation
• willemt/yabtorrent - Cross platform Bittorrent library
• clibs/amp - Abstract Message Protocol C implementation
• littlstar/request.cc - libcurl-backed HTTP request library for C++
• daddinuz/http - Http requests made easier
• aperezdc/netdial - Utility library to simplify socket setup code
• clibs/http-get.c - Simple HTTP GET requests backed by libcurl
• 4thel00z/libsniff - Simple library to help you with setting up a raw socket
• phoenixpinpoint/fido - Fido provides JS Fetch API bindings in C for use in WASM. Additionally Fido provides a simple Header, Request and, Response API.
• iana-tools/iana-headers-c - Autogenerated Standard Headers Registered By IANA

Libraries

• clibs/uv - Cross-platform asychronous I/O
• clibs/leveldb - LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values
• clibs/ck - Concurrency primitives, safe memory reclamation mechanisms and non-blocking data structures designed to aid in the research, design and implementation of high performance concurrent systems.
• beltex/libsmc - Apple System Management Controller (SMC) API
• brendanashworth/r3 - high-performance path dispatching library for the web
• qute/qute - AST generation library
• clibs/sophia - modern embeddable key-value database
• tzador/gl-matrix - Matrix and Vector library for High Performance OpenGL apps
• clibs/stb - stb single-file public domain libraries for C/C++
• daddinuz/option - Mimic Rust's Option type
• jwerle/libara - a library for constructing random access memory interfaces. Operations are asynchronous and are provided data structures for relaying memory between functions. It is built on top of libuv (libuv >= 1.x.x). It is inspired by Julian Gruber's abstract-random-access.
• septag/sx - Portable base library for C programmers, tailored for system programmers and game developers. Includes containers, hash-table, memory allocators, fibers, threading, random generator, timer, multi-threaded task scheduler, math (linear algebra/vector/matrix/tweening), etc..
• jwerle/libnanoresource - A C99 library for creating tiny async resources.
• jwerle/libram - A C99 library for creating random access memory interfaces.
• jwerle/libras - A C99 library for creating random access storage interfaces.
• jwerle/libalru - libalru is a library for creating really fast numeric based LRU caches that leverage an optimized CRC-16-CCITT ported over from @mafintosh's array-lru.
• andrerenaud/pdfgen - A minimalistic C99 library for creating PDF document.
• Immediate-Mode-UI/Nuklear - A single-header ANSI C immediate mode cross-platform GUI library.
• phoenixpinpoint/butterknife - A simple HTML templating system.
• phoenixpinpoint/fracture - Fracture provides a robust set of tools for developing web applications in C. Build to JS or WASM.

Preprocessor macros

• madmurphy/zen.h - C preprocessor utilities

Program flow

• jlcordeiro/threadpool - A simple thread pool implementation (POSIX)
• jwerle/async.h - Asynchronous goodies built on libuv
• stephenmathieson/batch.c - Simple async batch using pthreads
• ScientificC/errno - This repository contains some error handling modules used in the development of the libraries of SciC
• clibs/trigger - Simple event handling library.
• stephenmathieson/emitter.c - Tiny event emitter
• jwerle/throw.h - Create and throw errors easily
• 4thel00z/cry.h - Cry about your program (like throw.h) but with colors
• clibs/coro - Coroutines in C
• tylertreat/chan - Pure C implementation of Go channels
• trws/libdefer - Go-style defer in C
• willemt/uv_multiplex - Let's share one TCP socket across multiple threads
• willemt/bmon - Batch work from multiple threads
• guillermocalvo/exceptions4c - An exception handling library for C
• guillermocalvo/resultlib - Elegant error handling in C
• Mobiushorizons/closure_module - Standardized callback interface.
• aperezdc/autocleanup - Utility macros for typesafe RAII-style scoped cleanups for variables.
• goodcleanfun/threading - cross-platform C11 threads.h implementation that works on Linux, Mac, and Windows, plus a cross-platform read-write lock
• goodcleanfun/spinlock - simple test-and-test-and-set (TTAS) spinlock implementation using C11 atomics
• goodcleanfun/seqlock - a cross-platform sequence lock using C11 atomics, an efficient reader-writer synchronization mechanism for updating shared data (but not pointer-based structures) where reads vastly outnumber writes while also avoiding writer starvation.
• goodcleanfun/random_backoff Exponential backoff strategy with thread-local randomization to avoid contention. Can be used as part of any lock implementation or multi-threaded program.
• goodcleanfun/mcs_spinlock a Mellor-Crummey Scott queued spinlock using C11 atomics, which requires threads to spin only on their local node, better suited to NUMA architectures.
• goodcleanfun/ticket_spinlock a ticket lock for fair FIFO locking using C11 atomics where each lock acquisition is assigned a unique ticket number from an atomic counter and requests are served in order of their ticket, with each unlock incrementing the serving counter so that the next ticket can proceed.
• goodcleanfun/rw_ticket_spinlock small (50x smaller than pthread_rwlock_t), fair, reader-writer ticket-based spinlock which allows many readers to acquire the lock at the same time while allowing only one writer at at time and serves requests in FIFO order to prevent starvation of writers and readers.

Serialization

• willemt/heapless-bencode - Bencode reader that doesn't use the heap
• willemt/streaming-bencode - Bencode reader that loves working with streams

Testing/Quality Assurance

• orangeduck/ptest - DRY Microtesting for C
• clibs/debug - Conditional debug logging for C
• stephenmathieson/debug.c - Conditional debugging for C (again)
• hij1nx/debug - Conditional debug logging for C++
• stephenmathieson/describe.h - Simple BDD testing utility
• jwerle/libok - Super tiny tap output library
• thlorenz/tap.c - tap test runner
• jlcordeiro/minunit - A minimal, header-only, unit testing framework.
• stephenmathieson/assertion-macros.h - simple assertion macros (assert_equal, assert_str_equal, etc.)
• silentbicycle/greatest - A C unit testing library in 1 file. No dependencies, no dynamic allocation
• willemt/cutest - C unit testing
• jeradesign/MinUnit - JTN002: A minimal unit testing framework for C
• aperezdc/apicheck - Assertion macros for checking function parameters
• daddinuz/traits - An assertions library written in C99
• daddinuz/traits-unit - A unittest framework written in C99

Timing

• clibs/timestamp - millisecond resolution timestamps
• clibs/bench.h - get wall and cpu time for benchmarking
• clibs/timer - timer with microsecond resolution
• willemt/event-timer - A timer that fires events based off time
• brendanashworth/bench - easy to use, beautiful-looking benchmarking library
• opal-instruments/tiny-midi-clock - A small MIDI Beat Clock implementation with millisecond precision.

Executables

• visionmedia/watch - periodically execute commands
• visionmedia/mon - simple process monitoring
• visionmedia/histo - display histograms from static or streaming input
• jb55/extname - get file extensions from arguments
• jb55/samp - Sample input given some probability
• jb55/pidpath - Get the executable path from a pid on OSX
• sphia/sphia - Command line utility for operations on a sophia database
• stephenmathieson/tabs-to-spaces - convert tabs to spaces in files
• stephenmathieson/sophia-repl - REPL for Sophia databases
• hij1nx/ldb - A c++ repl for leveldb
• tomerdmnt/levelfs - leveldb FUSE filesystem
• jonathanmarvens/netmask-tool - Simple netmask utility.
• lavoiesl/osx-cpu-temp - Outputs current CPU temperature in °C for OSX
• clibs/entr - A utility for running arbitrary commands when files change
• stephenmathieson/ghi - less opinionated clib-install for non clib-enabled repos
• jwerle/suri - Set and get application URI schemes for OS X
• wooorm/stmr - Porter Stemmer CLI
• andik/makeheaders - make headers from .c source files
• wooorm/levenshtein - Levenshtein’s string edit distance algorithm CLI
• nilsding/cnsc - C No Scope Commits: Angular commits minus scope and stuff
• glisy/glisy-earth - Glisy example rendering glsl-earth and using glsl-fog for fade in effects.
• glisy/glsl-checker-blur - Glisy example using glsl-hash-blur and glsl-check from stack.gl

OS Specific

• mattn/ansicolor-w32.c - ANSI color support on windows
• onderweg/follow-the-sun - Automatic dark mode in macOS

Plugins

• clibs/clib-uninstall - plugin for uninstalling executables
• clibs/clib-validate - validate a package.json

Math

• ScientificC/cmathl - A pure-C math library with a great variety of mathematical functions. Seeks to be close to C89/C90 compliant for portability.
• jb55/bresenham-line.c - Bresenham's line drawing algorithm
• MauroMombelli/TrigonomeC - Basic implementation of 3d vector and quaternion
• MauroMombelli/FreeDCM - An implementation of Direct Cosine Matrix, a fast orientation algorithm
• willemt/minmax - min and max functions
• glisy/math - Common linear algebra functions for OpenGL
• littlstar/clamp - Macro to clamp a value between two other values
• catb0t/yacbnl - yet another C bignum library for C99
• erstan/ceval - Parse and evaluate math expressions
• tochinet/Posit - Posit arithmetic for embedded systems
• mofosyne/bound_and_clamp.c - Various macros and functions for validating and guarding signals in c (Bounds, Clamps, etc...)
• goodcleanfun/vectorized - Vectorized operations for numeric arrays using multithreading on larger arrays and SIMD in all cases if compiled with OpenMP. Includes cross-platform (via SIMDe) AVX2 vectorized implementations of exp, log, sin and cos.
• mofosyne/linmap.h - Lightweight Linear Mapping Library (e.g. ADC Conversion)
• goodcleanfun/simde_avx2 - pulls latest release from SIMD Everywhere, a well-tested header-only library which implements SIMD instruction sets for systems which don't natively support them e.g. will allow using AVX2 code on any platform and will generate the appropriate instructions, say NEON on Apple's M chips. This clib package only pulls in the necessary headers for supporting AVX2 instructions.
• goodcleanfun/simde_sse2 - pulls latest release from SIMD Everywhere, a well-tested header-only library which implements SIMD instruction sets for systems which don't natively support them e.g. will allow using SSE2 code on any platform and will generate the appropriate instructions, say NEON on Apple's M chips. This clib package only pulls in the necessary headers for supporting SSE2 instructions.

AVR

• opal-instruments/max7219-avr - max7219 LED Driver for AVR devices.

OpenGL

• glisy/glisy - Higher level operations for OpenGL
• glisy/glfw-shell - Setup a GLFW context and render loop now
• glisy/ease - Common easing functions
• glisy/math - Common linear algebra functions for OpenGL
• littlstar/sop - Simple OBJ Parser for deriving simplicial complexes and material data from .obj file formats exported from Blender/Max
• littlstar/soil - Simple OpenGL Image Library
• rswinkle/PortableGL - An implementation of OpenGL 3.x-ish in clean C

Profiling

• daddinuz/watchdog - A memory tracer useful to analyze memory usage or detect leaks.