Fastfetch is a high-performance, cross-platform system information fetcher designed for the command line. It detects and displays hardware (CPU, GPU, memory, disks, battery, displays, network, Bluetooth, etc.) and software (OS, kernel, desktop environment, window manager, packages, processes, etc.) with extensive customization options including ASCII art logos, images, and JSON output. The architecture is monolithic with a modular detection system: each subsystem (e.g., GPU, battery) has a platform-agnostic header and multiple platform-specific implementation files (Linux, macOS, Windows, BSDs, Haiku, Solaris, Android). The core common library provides dynamic string buffers (FFstrbuf), generic lists (FFlist), dynamic library loading helpers, file I/O, configuration parsing, and formatting utilities. Build configuration is CMake-based with optional dependencies (ImageMagick, libva, Lua, etc.). The codebase is written in modern C (C23) and demonstrates strong engineering practices with consistent patterns for module initialization, option parsing, JSON config generation, and error handling. It is actively maintained with frequent releases and broad platform support.
hcc is a compiler for the HolyC language, a derivative of TempleOS HolyC. It supports both ahead-of-time (AOT) compilation to x86_64 and AArch64 assembly and just-in-time (JIT) compilation for in-memory execution. The system includes a full front-end (lexer, parser, AST, SSA-based IR), optimization passes, register allocation, and backends for x86_64 and AArch64. Additionally, it provides a REPL, a Language Server Protocol (LSP) server, an inline assembler (TempleOS-style), a disassembler, and a control-flow graph visualizer. The standard library is written in HolyC and offers data structures (lists, vectors, hash maps, red-black trees), JSON/CSV parsers, SQLite bindings, networking, threading, coroutines, and system call wrappers. The project is a self-contained, well-structured compiler toolchain with extensive tests and active development.
Rufus is a Windows-native GUI application for creating bootable USB drives and formatting removable media. In production it is a single binary that drives raw disk I/O through Win32/NT APIs, parses ISO/WIM/VHD/FFU images, decompresses archives in many formats, formats to FAT/FAT32/NTFS/UDF/exFAT/ReFS/ext2/3/4, and writes MBR/PBR/bootloaders such as Syslinux and GRUB. It also implements Windows-specific features such as UEFI Secure Boot revocation updates, Windows To Go support, VSS snapshots, and dark-mode UI. Architecturally it is a classic monolithic C application: an autotools/VS build produces one executable with a Win32 dialog UI, a resource-based localization system, and tightly coupled modules for device enumeration, formatting, ISO mounting, and WIM application. The repo vendors a large collection of self-contained C libraries (wimlib, libcdio, ext2fs, ms-sys, syslinux libinstaller, bled decompression, getopt) and adapts them for Windows raw-block I/O. Runtime dependencies are Windows system DLLs, Microsoft symbol-server downloads, UEFI revocation databases, and optional network fetches of boot components. The project is actively maintained with CI workflows for VS2026 and MinGW, CodeQL, Coverity, and dependabot. Its code quality is characterized by defensive low-level Windows programming, careful handling of version-dependent APIs, and extensive real-hardware compatibility work. The main risk is technical drift: many vendored dependencies are snapshots of older upstream libraries, and several modules rely on undocumented or semi-documented Windows behavior.
Iris is a high-performance C inference engine for diffusion image generation models, specifically designed for FLUX.2 Klein (4B/9B) and Z-Image-Turbo (6B) architectures. It provides a complete pipeline from text encoding (Qwen3-4B/8B) through transformer denoising to VAE decoding, outputting PNG or PPM images. The system operates as both a standalone CLI tool with an interactive REPL and a C library (libiris.a), featuring memory-mapped weight loading for efficiency (~4-5GB peak for 4B model) and optional Metal GPU acceleration on Apple Silicon for significant speedups. The architecture is modular: separate components handle safetensors weight loading, BPE tokenization, transformer blocks (double/single stream for Flux, main/refiner for Z-Image), VAE decoding, and image I/O (PNG/JPEG/PPM). The CLI supports text-to-image, image-to-image, multi-reference generation, and various scheduling strategies (shifted sigmoid, linear, power). Memory optimization techniques include releasing the text encoder after embedding extraction, embedding caching with 4-bit quantization, and dynamic attention memory budgeting for reference images. The codebase demonstrates deep systems engineering and ML inference expertise, with hand-optimized kernels, custom Metal shaders, and detailed performance instrumentation. It is self-contained with no external dependencies beyond standard C libraries and optional BLAS/Metal, making it portable across Linux and macOS. The project includes regression test vectors and a JPEG decoder fuzzer, indicating a focus on correctness and reliability.
Gravity is an embeddable, dynamically typed scripting language written in portable C99 with no external dependencies beyond the C standard library. The repository implements a full language toolchain: a multi-pass compiler (lexer, Pratt parser, AST, IR, optimizer, bytecode codegen) and a register-based virtual machine with mark-and-sweep garbage collection. It provides a CLI (`gravity` executable) for running scripts and a well-defined C embedding API. The architecture is modular, with clear separation between compiler (`src/compiler`), runtime (`src/runtime`), shared utilities (`src/shared`), and optional modules (Math, File, JSON, ENV). The codebase is extensively tested with unit tests (embedded `#unittest` blocks) and a large fuzzing corpus for crash resistance. Despite some monolithic files (`gravity_core.c` >4000 lines) and heavy macro usage, the implementation demonstrates strong software engineering craftsmanship, especially in the hash table, dynamic array macros, and Pratt parser. The project appears to be under active maintenance (last commit 2026-08-05, 34 open issues, 4.5k stars) but shows some technical drift such as outdated CI configurations, platform-specific ifdefs, and a fuzz corpus from 2017.
MemReduct is a Windows desktop application for real-time memory monitoring and cleaning, implemented in C with the Win32 API and the undocumented Native API. It operates as a system tray utility that can manually or automatically purge various Windows memory caches: working sets, standby list, modified page list, system file cache, registry cache (Win8.1+), and combined memory lists (Win10+). The core cleaning logic uses NtSetSystemInformation with specific information classes, supplemented by volume cache flushing via the MOUNTMGR device. The application requires administrator privileges for full functionality and provides a configuration GUI with settings for auto-clean thresholds, intervals, hotkeys, language selection, and tray icon appearance. The architecture is monolithic: a single executable built from source files (main.c, main.h, resource files) that links against a reusable utility library (the 'routine' submodule). This library abstracts common Win32 tasks such as registry/INI config management, localization via .ini files, custom listview controls, theme handling, and device context operations. The application entry point is wWinMain in main.c, which creates the main dialog and processes window messages via DlgProc. Memory status is polled every second via a timer callback, and cleaning actions are triggered either manually through the UI or automatically based on user-defined thresholds. External dependencies are limited to Windows system DLLs (kernel32, user32, ntdll, advapi32) and the two submodules: 'routine' (utility code) and 'builder' (installer packaging). The build system uses Visual Studio 2017 project files with batch scripts for x86, x64, and ARM64 targets. No network dependencies exist except an optional update check. The codebase demonstrates non-obvious skill in low-level Windows system programming, custom GDI tray icon rendering, and conditional feature compilation, but remains maintainable through its separation of concerns in the routine library.
MQTT-SN Tools is a suite of four command-line applications for working with the MQTT-SN (MQTT for Sensor Networks) protocol. The system provides mqtt-sn-pub for publishing messages, mqtt-sn-sub for subscribing to topics, mqtt-sn-dump for monitoring packets, and mqtt-sn-serial-bridge for serial-to-UDP bridging. All tools share a common C library (mqtt-sn.c/h) that implements the MQTT-SN protocol handling, including socket management, packet encoding/decoding, keep-alive mechanics, and topic mapping. The architecture is modular with clear separation between the protocol library and application-specific logic. Each tool follows a standard pattern: parse command-line arguments, establish UDP connection to an MQTT-SN broker, perform protocol operations (connect, publish/subscribe, etc.), handle incoming/outgoing packets, and clean up resources. The project has active maintenance with recent commits and a test suite.
This repository is a step-by-step tutorial for building a minimal text editor called 'kilo' in C, based on antirez's original kilo. It is not a runnable application itself but a set of documentation and a diff file (steps.diff) containing the incremental code changes. The tutorial guides the user through 184 steps to create a terminal-based text editor with features like raw mode input, cursor movement, file I/O, search, and syntax highlighting. The code is a single C file with no external dependencies, targeting POSIX terminals. The repository is primarily educational, with the actual source code embedded in the diff file rather than as a standalone project. It has not been updated since 2017, making it stale, but the code remains functional on modern systems due to its simplicity and use of standard C99.