Open-source alternatives to Packages

This project is a suite of basic command line utilities rewritten in Rust, providing a cross-platform implementation of POSIX shell utilities. It serves as a portable CLI toolset designed to run across different operating systems and architectures. The implementation includes a WebAssembly shell environment, which allows these essential command line tools to be executed directly within a web browser without requiring a local installation. The toolset covers a broad range of system capabilities, including filesystem operations, text processing and stream editing, and system administration too

This project is an OpenWrt firmware build system and embedded Linux build tool designed to create customized router firmware images for NanoPi hardware. It functions as a network OS customization kit, providing a structured environment for compiling tailored operating system images that integrate specific drivers, packages, and kernel optimizations. The system distinguishes itself through deep hardware and performance tuning, including kernel-space flow offloading for traffic acceleration and symmetric multiprocessing interrupt balancing to prevent single-core processing bottlenecks. It enabl

Lede is an embedded Linux build tool and firmware build system designed to generate bootable operating system images for routers and embedded network devices. It functions as a network device OS compiler that manages toolchains and target architectures to produce customizable firmware. The system enables the creation of custom router operating systems by integrating external package feeds from remote Git repositories. This allows for the expansion of available software packages and the tailoring of network appliance features during the build process. The build environment covers toolchain-ba

mobile-ffmpeg provides a framework for mobile multimedia processing, allowing Android, iOS, and tvOS applications to execute video and audio transcoding and filtering tasks. It enables the integration of pre-compiled binaries into mobile projects to avoid manual cross-compilation for different hardware architectures. The project supports cross-platform compilation and the integration of third-party codecs and external libraries. It provides a mechanism to deploy universal binaries across multiple operating systems and different CPU architectures. The toolset covers media metadata analysis, r

GoReleaser is a release automation tool for building, packaging, and distributing Go binaries across multiple platforms and architectures. It functions as a cross-compilation build pipeline and binary distribution orchestrator that manages the end-to-end lifecycle of versioned software releases. The tool utilizes a declarative configuration pipeline based on a YAML definition file to automate the Go toolchain. It links Git tags to the compilation process, allowing for automated version tagging and the injection of build metadata and version strings into binaries via linker flags. Its capabil

Gox is a cross-platform build automator and command line tool designed for Go cross-compilation. It serves as a toolchain manager that builds and configures the necessary compilation tools and flags required to target diverse hardware platforms. The system automates the setup, installation, and provisioning of the assemblers and linkers needed for different operating systems and architectures. It manages the generation of executable binaries for multiple platforms in parallel, utilizing custom naming templates and linker flags to prepare software releases. The tool provides capabilities for

electron-builder is a cross-platform build automator and packaging tool for Electron applications. It bundles source code and dependencies into platform-specific installers, portable executables, and app store formats for Windows, macOS, and Linux. The project functions as a distribution pipeline that orchestrates the signing and notarization of binaries to ensure authenticity and bypass security warnings. It also serves as an auto-update orchestrator, preparing application packages and distribution channels to support automatic background software updates. Its capability surface covers the

This project is a tutorial for developing a custom bare metal operating system specifically for the Raspberry Pi 4. It provides the guidance and resources necessary to write software that interacts directly with hardware without the use of a pre-existing kernel. The project centers on an ARM64 cross-compilation toolchain and a build pipeline that transforms source code into raw binary images. It utilizes linker scripts to define physical memory addresses and section placements, ensuring the resulting binary loads at the correct hardware entry point. The codebase covers direct hardware interf

Skill-Tree is an educational framework designed to map theoretical technical concepts to practical implementation pipelines and structured interview preparation. It organizes technical knowledge into a tree-based index to enable structured navigation and uses a theory-to-implementation pipeline to verify conceptual understanding through concrete software tasks. The project provides curated study paths and cross-referenced indexing that links common interview questions and simulated exam sets to specific technical modules. It employs module-based subject isolation to separate diverse backend d

Cargo-zigbuild is a build tool that compiles Rust projects for different operating systems and architectures using the Zig compiler as an external linker. It functions as an environment-driven wrapper that intercepts standard build commands and injects the target configurations, paths, and flags required for cross-compilation without requiring complex native toolchains. The tool enables cross-platform compilation workflows and configures minimum required standard C library versions for Linux builds by appending version suffixes directly to target specifications. It also packages multi-archite

The project is a development kit and compilation toolchain that builds C and C++ source files into native machine code libraries and shared library packages for mobile execution. It integrates target architecture toolchains with standard build systems to transform source code into deployable native modules. The toolset includes debugging and profiling capabilities that bridge low-level system debuggers with compiled binaries to inspect runtime execution states, register contents, and memory layouts. It provides performance monitoring instrumentation to measure execution bottlenecks and resour

This project is a collection of management interfaces and platforms for network-connected hardware. It functions as a firmware extension platform, a network storage operating system manager, and a network routing administrator. The system enables the installation of open-source plugins and third-party add-ons to expand device capabilities. It provides a management interface for network attached storage, allowing for remote file management and peer-to-peer media streaming. Broad capabilities cover network routing configuration through policy-based routing and dynamic DNS, as well as firmware

GopherJS is a cross-compiler toolchain that converts Go source code into JavaScript. It functions as a transpiler, enabling the execution of statically typed Go code within web browsers and other standard JavaScript runtime environments. The project provides a comprehensive implementation of the Go standard library, replacing system-level calls with browser-compatible APIs to maintain language semantics. It maps Go's memory allocation patterns and type definitions onto the host JavaScript engine, while utilizing source map generation to allow for debugging using original Go source files. By

python-build-standalone is a toolchain designed to produce redistributable Python executables across multiple operating systems and hardware architectures. It generates standalone Python binaries that can be distributed to users without requiring a pre-installed system interpreter. The project manages the end-to-end process of cross-platform compilation using target triples and containerized environments to ensure consistent binary output. It includes a distribution pipeline that automates the generation of build matrices and the uploading of compiled artifacts to public release pages and mir

Zig is a low-level systems programming language designed for writing high-performance software that interacts directly with hardware. It focuses on the transformation of source code into machine binaries for the execution of low-level operations. The project is distinguished by its native support for cross-compilation, allowing binaries for various operating systems and CPU architectures to be built from a single host. It provides direct interoperability with the C language, enabling the import of headers and function calls without a foreign function interface. The language utilizes manual m

This project provides an educational framework and laboratory environment for learning operating system kernel development specifically for the RISC-V architecture. It serves as a structured course that guides users through the process of building a functional kernel from scratch, offering the necessary resources to understand low-level system programming and architecture-specific software implementation. The toolkit distinguishes itself by integrating a complete development environment that bridges the gap between source code and hardware execution. It includes automated build scripts for cr

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

Luma3DS is a custom firmware for the Nintendo 3DS that removes factory restrictions to enable the execution of unsigned homebrew and game modifications. It functions as a kernel-level system extension that hooks system calls to bypass hardware limitations and introduce new operating system capabilities. The project serves as a homebrew payload loader, using boot-time mechanisms to launch third-party software and custom firmware versions. It also provides a game modding framework capable of patching executable code and intercepting file requests to load custom assets and modified data. The en

Nexe is a cross-platform binary bundler and compiler that packages Node.js applications and their dependencies into single standalone executables. It functions as a runtime compiler that can build the Node.js runtime from source with custom flags and application snapshots to enable software distribution without requiring a pre-installed runtime. The system allows for cross-compilation across different operating systems and architectures from a single build environment. It includes a static asset bundler to embed external files and directories directly into the compiled binary for access at ru

This project provides a Linux kernel development environment and a system emulation suite for building and debugging kernel modules and baremetal assembly across multiple hardware architectures. It functions as a comprehensive sandbox and framework for low-level system development, utilizing QEMU to simulate hardware environments without the need for physical devices. The environment integrates cross-compilation toolchains using Buildroot and crosstool-NG to target x86_64, ARMv7, and ARMv8 platforms from a single host. It features a specialized kernel debugging framework that leverages GDB an

This repository contains the source code for a C-based network botnet designed to compromise Internet of Things devices. It serves as a functional implementation of malware used for security research, behavioral analysis, and the development of threat detection signatures. The project includes a command and control server architecture that manages infected devices via a custom binary protocol and TCP-based command distribution. It employs a cross-compilation toolchain to build and deliver architecture-specific binary payloads across multiple hardware platforms. The codebase covers capabiliti

Bower is a frontend package manager and client-side asset manager used to install and track third-party JavaScript and CSS libraries for browser-based projects. It functions as a web dependency manager that ensures consistent versioning across different development environments. The tool operates as a Git-based dependency manager, retrieving source code directly from Git repositories rather than relying on a central package registry. It utilizes a semantic versioning resolver to match manifest constraints against Git tags to determine the correct package version. To prevent nested directory t

ISPC is a vectorizing compiler and SIMD parallel programming language that implements a single program multiple data model. It serves as a toolchain for translating C-based code with parallel extensions into optimized machine code for various CPU and GPU architectures using an LLVM backend. The compiler is designed for cross-platform SIMD toolchain support, generating specialized instruction sets for x86 SSE/AVX, ARM NEON, and Intel GPU from a single source. It features a runtime dispatch mechanism that selects the most efficient hardware-specific implementation for the current system during

FFmpeg-Builds is a cross-platform compilation toolchain and custom build system designed to generate static executables of the FFmpeg multimedia framework. It provides a distribution of pre-compiled binaries for multiple operating systems and hardware architectures. The project utilizes a Docker-based build environment to isolate toolchains and dependencies. This containerized approach enables multi-architecture cross-compilation and allows for parameter-driven feature selection to include specific codecs, libraries, and license options in the final binaries. The system manages the entire wo

This project is a game decompilation project consisting of a reconstructed C source codebase and the systems used for binary reconstruction. It provides a human-readable version of a commercial game title created through static and dynamic analysis to facilitate technical study and modification. The project utilizes a containerized build environment to ensure reproducible compilation and consistent toolchain versions across different host operating systems. It includes a game binary reconstructor that translates original machine code into source code and a system for compiling the codebase in

Asuswrt-Merlin is a custom router firmware that provides an enhanced version of the original manufacturer software. Its primary purpose is to offer additional features, bug fixes, and advanced configuration options not available in standard factory firmware. The project utilizes a modification process that applies binary patching and a layered firmware overlay to a proprietary distribution. This approach allows for the implementation of kernel extensions and functionality adjustments while maintaining compatibility with the original hardware. The software covers broad capability areas includ

This is a custom firmware build for ASUS routers that enhances the stock operating system by fixing known bugs and stability issues while preserving the original user interface. It adds minor feature adjustments and configuration options to the router's web-based administration panel without replacing its core functionality. The project modifies the original vendor firmware source code at the file level to apply targeted fixes and feature additions, using separate code branches to manage different firmware versions and release tracks. It incorporates pre-compiled proprietary drivers and firmw