Open-source alternatives to Cargo Bloat

PlatformIO Core is a toolset for embedded software development that manages the compilation, flashing, and debugging of firmware for various microcontroller targets. It provides a cross-platform build system that automates the process of transforming source code into binaries and transferring them to hardware via serial protocols. The system uses a plugin-based architecture to extend hardware platform support and incorporates a manifest-driven approach to resolve and install the specific toolchains, frameworks, and libraries required for different board definitions. Capabilities cover the fu

This project is a version-controlled Git archive and software archaeology dataset containing the continuous evolution of Unix source code from 1970 to the present. It serves as a chronological record of system history, synthesizing a versioned code timeline from disparate historical snapshots. The archive enables longitudinal software analysis by reconstructing a sequence of commits and merges from fragmented releases. This allows for the tracking of system evolution and the attribution of specific lines of code to original authors through synthesized version control metadata. The dataset co

Bloaty is a binary size profiler and executable format analyzer that attributes every byte of a binary to specific symbols or compile units. It functions as a compilation unit profiler and C++ symbol demangler, mapping binary size back to source files and translating mangled names into human-readable formats. The project distinguishes itself as a binary diffing tool capable of comparing two versions of a binary to isolate specific symbols or sections responsible for size regressions. It provides specialized support for recovering symbols in stripped binaries by associating them with external

F Prime is a component-based framework designed for the development and deployment of embedded and spaceflight software. It provides a modular architecture that decouples software logic from communication interfaces, allowing developers to define system structures through a domain-specific modeling language. This model-based approach enables automated code generation, ensuring consistency across complex system topologies while maintaining strict interface contracts between software modules. The framework distinguishes itself through its integrated build system and ground data operations suite

Checkstyle is a Java static analysis tool and linter designed to identify and enforce coding standards and best practices. It functions as a code quality auditor and Javadoc validation tool, checking source code against configurable rulesets to ensure structural and stylistic consistency. The project allows for the creation of custom linting rules by extending a core API to inspect the abstract syntax tree. It further enables specialized validation through the use of XPath expressions to query the syntax tree for specific code patterns and violations. Capability areas include the enforcement

The Rust Programming Language Book is the official technical guide and educational resource for the Rust language. It provides a comprehensive walkthrough of the language's design, focusing on its core identity as a systems programming language that enforces memory safety and high-performance execution without the need for a garbage collector. The project is distinguished by its focus on ownership, borrowing, and lifetime tracking, which allow the compiler to verify memory safety and thread safety at compile time. It covers the language's unique approach to zero-cost abstractions, including t

NuttX is a POSIX-compliant real-time operating system designed for microcontrollers ranging from 8-bit to 64-bit architectures. It provides a deterministic execution environment with a real-time task scheduler and a POSIX embedded kernel to ensure portable code execution across diverse hardware targets. The project distinguishes itself through a comprehensive hardware abstraction layer that provides standardized drivers for I2C, SPI, CAN, and USB across various semiconductor chipsets. It also features an embedded networking stack supporting TCP, UDP, IPv4, and IPv6, alongside industrial proto

Wild is a binary linker and compiler integration tool used to merge multiple object files into single executable binaries, shared libraries, or static archives. It functions as a replacement for standard system linkers, automating the final stage of the compilation process to generate binaries across different operating system architectures. The project provides custom binary linking and toolchain integration, allowing for the modification of how compilers resolve symbols and determine memory layouts. It specifically handles the organization of machine code and data sections to meet the requi

iOS-Runtime-Headers is a collection of Objective-C header files and tooling used to expose private and undocumented iOS system APIs. These definitions are generated through runtime introspection of the live operating system to uncover hidden class methods and properties. The project enables the use of undocumented iOS API definitions for internal Apple frameworks. It provides the necessary header files to allow a compiler to link against private system symbols and verify types for undocumented system calls. The tooling covers several technical areas, including memory-mapped metadata extracti

Orbit is a set of specialized tools for C and C++ performance profiling, binary symbol mapping, and remote process and thread analysis. It provides a system for analyzing execution time and resource usage, utilizing a call graph visualizer to map function entries and exits into hierarchical execution flows for individual threads. The project distinguishes itself with a remote process profiler capable of capturing performance data from applications running on remote hosts. It also includes a thread scheduling analyzer that tracks context switches and processor core utilization to visualize thr

Volatility3 is a memory forensics framework and analysis tool used to parse volatile memory dumps. It extracts digital artifacts and reconstructs the runtime state of a system to recover process information, network artifacts, and other forensic evidence. The system functions as a plugin-based forensic engine and an operating system symbol resolver. It maps raw memory addresses to known system structures using symbol tables and translation layers, and provides an extensible architecture for creating custom scanners and renderers. The framework includes a command-line memory explorer for real

RIOT is a real-time operating system designed for resource-constrained microcontrollers. It provides a kernel for managing hardware peripherals, memory, and multitasking on embedded devices, featuring a microcontroller hardware abstraction layer to unify hardware access across different chipsets. The system employs a preemptive tickless task scheduler with priority-based execution to maximize energy efficiency in battery-powered hardware. It also includes an embedded security framework consisting of cryptographic APIs and secure transport protocols to facilitate authenticated over-the-air fir

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re

Hardhat is a smart contract development framework and EVM tooling suite designed for the full lifecycle of Ethereum and EVM-compatible applications. It serves as a development environment for compiling, testing, and deploying smart contracts, providing a local blockchain simulation and a programmable task runner. The framework is distinguished by its extensive simulation capabilities, including the ability to fork remote network state and manipulate block time or account balances. It features a hook-based plugin system that allows for the extension of core functionality and the creation of cu

Grin is a compiler infrastructure designed for the translation and optimization of high-level functional languages. It functions as a graph-reduction compiler, transforming source code into a standardized intermediate representation that facilitates whole-program analysis and efficient execution across diverse hardware architectures. The project distinguishes itself through a modular backend infrastructure that separates intermediate representation management from target-specific code generation. By utilizing graph-based transformations, the system performs advanced optimizations such as valu

This project is a structured Rust programming curriculum and systems programming course designed to take learners from beginner to expert levels. It provides a comprehensive set of training materials focused on mastering the core syntax, idioms, and technical foundations of the Rust language. The project features a specialized language transition framework that maps concepts from C++, managed languages, and dynamic typing to Rust idioms. This allows developers from different ecosystems to translate architectural patterns and memory models into idiomatic Rust. The training covers a broad rang

This library provides a collection of low-level abstractions for interacting with hardware peripherals on Raspberry Pi devices using the Rust programming language. It serves as a type-safe interface for controlling physical pins and managing communication with external electronic components and sensors. The project distinguishes itself through its use of compile-time abstractions that map high-level function calls directly to hardware instructions, ensuring minimal runtime overhead. It provides consistent access to hardware by wrapping kernel-level device interfaces and memory-mapped register

This repository contains the complete source code for a Unix-like operating system, including the monolithic kernel and base system utilities. It provides a BSD-derived system core and a full build toolchain required to compile a functional operating system for servers, desktops, or embedded devices. The system features a Linux binary compatibility layer that enables the execution and emulation of Linux binaries on a non-Linux platform. It also includes a modular kernel configuration process to tailor hardware support and system features during compilation. The project covers broad system ca

Open-smartwatch-os is an operating system designed for resource-constrained wearable devices. It provides a development and testing environment that allows developers to build, validate, and debug firmware for smartwatches within a simulated desktop environment before deploying to physical hardware. The project distinguishes itself through a comprehensive suite of tools for hardware emulation and remote diagnostics. By utilizing a hardware abstraction layer and modular driver architecture, it decouples core system logic from specific physical components. This enables developers to run the ope

open62541 is an open-source implementation of the OPC Unified Architecture standard, providing a complete stack for industrial automation and data exchange. It functions as both an OPC UA server and client, enabling the creation of an object-oriented address space to model physical industrial assets and their relationships. The project is designed for versatility across diverse hardware, offering a C99 library that can be deployed to both cloud servers and resource-constrained embedded environments. It distinguishes itself through a pluggable network layer and interface-based security backend

Pants is a monorepo build system designed to manage multi-language software projects within a single repository. It functions as a polyglot task runner and distributed build orchestrator, providing a unified interface for executing compilers, linters, and test runners across different programming languages. The system is distinguished by a dependency analysis engine that uses static source code analysis to model software dependencies, removing the need for manual build metadata files. It ensures reproducible builds through hermetic isolation and protects the software supply chain using depend

bflat is a native compiler and ahead-of-time binary generator for C#. It transforms source code into self-contained native executables and machine code that run without requiring a separate runtime environment. The project features a cross-platform native toolchain capable of generating binaries for multiple operating systems and architectures from a single environment. It includes a mechanism for exporting C# logic as shared native libraries via a foreign function interface for integration with other programming languages. To support resource-constrained environments, it provides a binary o

This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

ArduinoJson is a C++ library for parsing and manipulating JSON data and MessagePack binary streams on microcontrollers with limited memory and processing power. It provides the core primitives necessary for embedded data serialization and parsing, enabling devices to exchange structured data over serial or network interfaces. The library is distinguished by its focus on microcontroller memory management, employing strategies such as pool-based allocation, string deduplication, and non-owning string views to minimize RAM usage. It further optimizes for constrained environments by allowing cons

Blade-build is a multi-language build system and software orchestrator designed to automate the compilation, linking, and testing of complex codebases. It functions as an incremental build engine that models project structures as directed acyclic graphs, ensuring that only affected modules are recompiled when source code or header files change. By utilizing declarative build specifications, the system provides a unified approach to managing dependencies and toolchains across diverse programming environments. The system distinguishes itself through a focus on hermetic build environments and re

This project is a professional integrated development environment designed for microcontroller firmware engineering and embedded systems development. It provides a specialized interface for writing, compiling, and deploying code to Arduino-compatible boards and various other hardware platforms. The environment distinguishes itself through a modular architecture that separates the graphical user interface from the underlying build and hardware communication logic. By utilizing a language server protocol and a decoupled plugin system, it allows for consistent code analysis and extensible functi

This project is a development toolkit and starter kit for creating custom WordPress themes. It provides a standardized scaffolding tool to initialize a minimal codebase and directory structure, serving as a foundation for building custom site designs. The toolkit includes a build pipeline that automates the compilation of Sass into browser-ready CSS and the generation of mirrored right-to-left stylesheets. It further assists in theme preparation through a translation template generator that extracts translatable strings into portable object files. The system covers a broad range of developme