Open-source alternatives to Docker Alpine

This project is a suite of specialized tools for linting, minifying, analyzing, and managing container images and their associated registries. It provides a set of utilities including an image minifier to reduce image size, a security profiler to harden running containers, an image analyzer for static inspection, and a registry manager for organizing multi-architecture indices. The toolset distinguishes itself through behavior-based optimization and security. It uses dynamic analysis to track executed instructions and file access to remove unused binary data, and records kernel interactions t

Slim is a comprehensive suite for container lifecycle management, providing tools for image inspection, optimization, security hardening, and service troubleshooting. It functions as a platform for analyzing containerized applications through both static metadata review and dynamic behavioral probing, enabling users to understand image composition and runtime dependencies. The project distinguishes itself by automating the creation of minimal, production-ready container images. It achieves this by removing unnecessary files and components, flattening image layers, and synthesizing restrictive

Dive is a command-line tool designed for the analysis and optimization of container images. It functions as a layered storage inspector, allowing users to decompose image manifests to examine individual filesystem layers and identify opportunities to reduce total image size. The tool features a filesystem diffing engine that calculates net changes between sequential layers to highlight redundant data and storage inefficiencies. Users interact with this data through a terminal-based dashboard that provides keyboard-driven navigation of complex file structures and layer metadata. By abstracting

Distroless provides a collection of security-hardened, minimal base container images designed to reduce attack surfaces by excluding non-essential system utilities, package managers, and shells. These images are constructed to contain only an application and its specific runtime dependencies, enforcing the principle of least privilege by configuring environments for non-root execution. The project distinguishes itself through a focus on supply chain integrity and reproducible builds. It utilizes declarative build configurations to track package versions and validates container image integrity

This project is an administrative reference for Docker, providing guides and command references for system maintenance, image building, network configuration, and security hardening. It serves as a comprehensive manual for managing the container lifecycle and performing general system administration. The reference covers the construction and optimization of images through build files, layering strategies, and registry integration. It also provides instructions for configuring isolated virtual networks, mapping ports, and implementing security hardening using Linux capabilities and read-only f

This project is a collection of common Unix utilities compiled as statically linked binaries. It provides a portable Nix toolset and a bundle of POSIX utilities designed to run across different Linux distributions without requiring shared library dependencies. The collection focuses on cross-distribution compatibility and minimal environment setup. By utilizing a musl-based toolchain and static-link compilation, these utilities are distributed as standalone files that execute immediately without the need for a package manager or external system packages. The project covers a range of portabl

Distroless provides a set of OCI-compliant minimal base images and hardening tools designed to create secure, language-specific execution environments. These images are stripped of non-essential system binaries, shells, and package managers to reduce the container attack surface. The project utilizes upstream-tracked automated patching to monitor operating system releases and generate updated images when security vulnerabilities are addressed. It ensures supply chain integrity through image provenance verification using ephemeral-key digital signatures. The system supports the generation of

Musl-cross-make is a build system that automatically downloads, patches, and compiles source components to generate relocatable cross-compilation toolchains targeting the musl C library. It functions as an automated build environment for creating custom cross-compilers and standard library toolchains for alternative target architectures. The system orchestrates the sequential downloading, patching, configuring, and compiling of multi-component toolchains, applying distribution-specific bug fixes and architecture patches directly to extracted source trees. It downloads required upstream source

Ish is a Linux shell emulator for iOS that provides a local terminal environment for running shell commands and managing files. It functions as an instruction-level emulator that enables the execution of Linux binaries on mobile devices by simulating an Alpine Linux environment. The project distinguishes itself by combining user-mode Linux emulation with a virtual root filesystem. This allows the software to map Linux kernel system calls to host functions and execute scripts and toolsets directly on an iPhone or iPad. The emulator also provides low-level program debugging capabilities, inclu

Hadolint is a static analysis tool designed to validate container build configurations. It functions as a security scanner and configuration auditor, parsing build instructions into a structured format to identify deviations from security and efficiency standards. The tool distinguishes itself by performing deep inspection of embedded shell commands. By tokenizing and analyzing these scripts, it detects common scripting errors and security vulnerabilities that might otherwise persist within a container image. It integrates external analysis tools to provide specialized validation for these in

This project is a production-ready Docker deployment template for FastAPI applications. It provides a standardized Python web application container that integrates Uvicorn as the ASGI server and Gunicorn as the process manager to handle concurrent requests across multiple CPU cores. The configuration enables performance tuning by adjusting worker processes and server settings based on available CPU resources. It utilizes a multi-stage Docker build to separate build dependencies from the final runtime image. The system covers containerized web hosting, including support for environment-variab

This project is a collection of techniques and configurations for reducing the disk footprint of compiled Rust executables. It serves as a guide and toolset for binary size optimization, providing strategies to minimize the final executable size through compiler flags and configuration. The project focuses on aggressive size reduction strategies, including recompiling the standard library from source to prune unused functions and implementing no-standard-library modes for memory-constrained environments. It details how to eliminate runtime overhead by removing standard library entry points an

This project is a collection of best practices and curated templates for building secure, stable, and production-ready Docker images. It provides standards for OCI image optimization and a guide for implementing industry-standard configurations in container environments. The repository offers specific patterns for security hardening, such as implementing non-root user execution with static IDs to prevent host privilege escalation. It also provides structural templates for multi-stage builds to separate build-time dependencies from the final runtime environment. Additional capabilities cover

dockerlabs is a collection of educational labs and technical tutorials designed to teach the fundamentals of containerization and microservice architecture. It provides instructional material and hands-on exercises covering image optimization, security training, infrastructure setup, and cluster orchestration. The project features specific courses and guides focused on reducing image size through multi-stage builds, securing workloads via vulnerability scanning and encrypted networks, and deploying multi-node clusters with high availability using Swarm orchestration. The materials cover a br

This project provides a collection of implementation kits, guides, and source code designed to teach containerized application development and cluster management. It serves as a learning path for packaging applications with Docker and orchestrating workloads within Kubernetes. The repository includes practical walkthroughs for building automated delivery pipelines using containerized runners and build agents. It also provides a suite of guides for implementing cloud-native observability, deploying service meshes, and managing Kubernetes cluster configurations. The material covers a broad ran

Hadolint is a Dockerfile linter and Haskell-based static analysis tool. It analyzes container image configuration files against a set of rules to ensure valid syntax and adherence to best practices. The tool functions as a wrapper for shell checkers to inspect inline shell commands and scripts within build instructions, identifying scripting errors and bugs. It also includes security auditing capabilities to warn when images are pulled from registries not explicitly listed as trusted. The analysis engine covers quality assurance through label schema validation, syntax pattern verification, a

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

This project is a boilerplate and template for Go applications implementing Clean Architecture. It provides a standardized project structure designed to organize code into decoupled layers, ensuring that core business logic remains independent of databases, frameworks, and user interfaces. The implementation focuses on a domain-driven design that utilizes dependency injection and the repository pattern to abstract data storage. It enforces architectural boundaries through internal package encapsulation and layer-based dependency inversion. The project includes a development toolchain that au

This is an educational training course that teaches Docker, Compose, Swarm, and Kubernetes for building and deploying containers from development to production. The course covers end-to-end Docker-based workflows for building, testing, and deploying containers using Compose, Swarm, and Kubernetes in cloud-native DevOps pipelines. The material covers architecture patterns for containerized applications, including declarative service orchestration, network bridging, image layering, health monitoring, and persistent storage across Docker and Kubernetes environments. It addresses multi-container

This project is a type-safe web application template and admin dashboard starter built with Next.js, TypeScript, and the shadcn/ui component library. It serves as a multi-tenant SaaS boilerplate designed for developing administrative interfaces and software-as-a-service applications. The starter distinguishes itself through integrated SaaS infrastructure, including multi-tenant workspace management, organization-level permissions, and subscription billing integration. It features role-based access control to gate specific pages and navigation items based on user roles or subscription tiers.

This project is a cloud-native software distribution and an OCI container image library. It provides a collection of pre-configured, hardened container images and Docker Compose application stacks designed for consistent deployment across cloud and on-premises environments. The images are production-ready and compiled using standardized security configurations and vulnerability scanning to reduce attack surfaces. These hardened application images are designed to minimize manual setup and security risks during deployment. The project covers container vulnerability management, production-ready

This project provides a comprehensive architectural framework and set of standardized patterns for building, securing, and scaling production-ready Node.js applications. It serves as a foundational guide for establishing consistent development workflows, operational observability, and reliable service integration across distributed software systems. The framework distinguishes itself by emphasizing a schema-first approach to API development, ensuring that interface definitions drive the creation of server stubs, client libraries, and type definitions. It promotes a cloud-native posture by int

This project is a Docker container image library providing official Dockerfiles and configurations for deploying enterprise software and database products. It serves as a source of container specifications and OCI compatible image repositories for packaging commercial application software into standardized container images. The repository specifically focuses on Oracle software containerization, offering pre-configured images and build scripts to deploy Oracle database instances in containerized environments. The project implements a standardized image build workflow and utilizes multi-stage

Moon is a monorepo build system and task runner designed to orchestrate complex projects with multiple packages. It functions as a dependency graph orchestrator that executes build targets in topological order and utilizes input hashing to cache results and skip redundant work. The project features a polyglot toolchain manager that automates the installation and versioning of language runtimes and CLI tools to ensure environment consistency. It also includes a plugin framework based on WebAssembly, allowing developers to extend build logic and toolchain behavior using any supported language.

This project provides a standardized Python Docker image, serving as a Linux-based runtime environment for executing Python applications. It is an OCI-compliant container designed to ensure consistent software execution across different platforms. The images support containerized application deployment, enabling environment parity between local development and remote servers. This foundation allows for the creation of standardized build pipelines and the development of microservices architectures. The build process incorporates multi-stage builds and layered image hierarchies to manage image

This project provides official container images for the Node.js runtime and its package managers. It serves as a containerized JavaScript runtime that bundles the engine and dependencies to ensure consistent application execution across different CPU architectures and operating systems. The project offers a range of Linux-based runtime images, including full, slim, and minimal distributions, allowing users to balance package availability against disk footprint. To improve security, it provides a non-root application environment that executes processes as an unprivileged user. The available i

This project is a collection of reference implementations and demonstration projects covering computer vision, DevOps automation, distributed systems, and Java-based microservices. It provides a programming reference library and practical examples for building server-side applications, containerizing services, and orchestrating clusters. The repository features a comprehensive toolset for DevOps automation, including scripts and playbooks for CI/CD pipelines and automated cluster installation. It includes a computer vision demo project for image object detection and facial analysis, as well a