Cross-compilation tooling

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

Cross is a container-based build environment and cross-compilation tool for Rust. It functions as a multi-architecture binary builder and testing framework, allowing users to compile crates into binaries for different operating systems and CPU architectures without installing local toolchains on the host system. The project distinguishes itself by using Docker images to provide consistent toolchains and system dependencies for foreign target architectures. It integrates the Zig toolchain within container images to facilitate compilation across various architectures and library versions, and i

This project is a cross-compiler toolchain for RISC-V software development. It provides the necessary components to compile C and C++ source code into executable binaries and libraries specifically for the RISC-V hardware architecture. The toolchain supports multi-architecture binary generation and multilib capabilities, allowing a single installation to target various instruction set specifications and bit-widths. It integrates with alternative compilers such as LLVM and Clang and includes a bootstrapped build pipeline to produce high-performance versions of the tools. The system covers bro

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

Cross compiling toolchains in Docker images

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

Llvm-mingw is an LLVM-based cross-compiler toolchain and MinGW-w64 development suite that builds native Windows executables from non-Windows operating systems using Clang and LLD. It compiles C and C++ source code into native portable executable binaries targeting multiple Windows CPU architectures from a single host environment. The toolchain supports configuring builds to use specific C runtime library targets for compatibility across different operating system versions. It includes capabilities for producing native Windows debug information and CodeView debug symbols alongside compiled bin

Docker images for compiling static Rust binaries using musl-cross

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 repository is the Armbian build framework — an embedded Linux build system for generating custom operating system images tailored to single-board computers, primarily targeting ARM and RISC-V architectures. The build process is orchestrated by GNU Makefiles and relies on a chroot-based environment to assemble the root filesystem, manage cross-compilation toolchains, and aggregate binary firmware blobs for hardware compatibility. Kernel and bootloader source trees are fetched via git, with structured patches applied in a controlled sequence, while each supported board is described by a ded

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

Proton is a compatibility layer designed to enable the execution of Windows-based software on non-Windows operating systems. It functions as a controlled runtime environment that maps proprietary system calls to native kernel functions and translates graphics API commands into open-standard compute shaders. This allows applications to run without requiring modifications to their original source code. The project distinguishes itself through a robust toolchain for reproducible builds, which utilizes containerized isolation to ensure consistent binary outputs across different development enviro