Open-source alternatives to Image Spec

IPFS is a peer-to-peer hypermedia protocol and content-addressed storage system that identifies data by cryptographic hashes rather than network locations. It enables the creation of a decentralized web by organizing files and directories as directed acyclic graphs of linked content identifiers. The project differentiates itself through the use of a distributed hash table for locating peers and a system of signed records to map human-readable names to changing content. It also provides HTTP gateways that translate standard web requests into peer-to-peer queries, allowing decentralized data to

Distribution is an open-source container image registry that implements the OCI Distribution Specification, enabling any OCI-compatible client to push, pull, and manage container images over standard protocols. It serves as a content distribution toolkit for packaging, shipping, storing, and delivering container content across networked environments, storing and retrieving content by its cryptographic hash for integrity and deduplication. The registry separates image metadata from bulk data to enable efficient validation and partial pulls, and supports resumable blob uploads with chunked tran

js-ipfs is an HTTP client library that connects to any IPFS daemon, enabling JavaScript applications to interact with the InterPlanetary File System. It provides a promise-based asynchronous API for managing content-addressed storage, where all data is identified by cryptographic hashes (CIDs) for immutable references and deduplication. The library communicates with a remote IPFS node through HTTP requests, supporting cancellation of in-flight operations via standard AbortController signals. The library offers a comprehensive set of capabilities for working with IPFS, including adding and ret

Kubo is a peer-to-peer implementation of the InterPlanetary File System (IPFS) designed for decentralized data storage and content delivery. It uses content-addressing, directed acyclic graphs, and distributed hash tables to identify, distribute, and retrieve data across a network without relying on central servers. The project differentiates itself by providing a virtual filesystem via FUSE, which maps decentralized network namespaces to local operating system directories for direct file access. It also includes integrated HTTP gateways that translate peer-to-peer content into standard web t

img is a collection of toolsets for building, managing, and manipulating OCI compliant container images. It functions as an image build tool and registry client, providing the capabilities to create images from configuration files, push and pull images to remote registries, and extract image layers into root filesystems or archives. The project distinguishes itself through support for multi-platform builds using hardware emulators and the ability to perform unprivileged container builds via namespace-based process isolation and user ID mapping. It also includes a cross-platform binary compile

Isomorphic-git is a full implementation of the Git version control system written in JavaScript. It serves as a programmatic client library that allows developers to perform core version control operations without requiring a system-level Git binary installation. The library is designed as an isomorphic codebase, meaning it runs identically across both client-side web browser environments and server-side Node.js runtimes. It achieves this by using a filesystem-agnostic storage model and a pure JavaScript implementation of the Git core logic and the Smart HTTP protocol. The project covers a c

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

The project provides an open container runtime specification and standardized schema for defining container configurations, namespaces, resource limits, security policies, and filesystem mounts across platforms. It outlines the formal configuration formats, lifecycle operations, and execution environments necessary for portable, isolated container workloads. The specification covers container lifecycle management protocols and structured rules governing container creation, execution startup, process signaling, state tracking, and resource teardown. It standardizes local bundle packaging and

proot-distro is a rootless container runtime and Linux distribution manager that allows users to install and run isolated guest environments without requiring administrative root privileges. It utilizes PRoot to simulate root access and filesystem redirection, enabling the deployment of full Linux distributions in a non-root space. The project functions as an OCI container image handler, capable of building, pulling, and pushing OCI-compatible images and manifests. It further serves as a cross-architecture execution layer, utilizing user-mode emulation to run binaries and containers built for

Buildah is a tool for creating OCI-compliant container images without requiring a background daemon process. It functions as a daemonless image constructor and distribution tool, allowing users to build, push, and pull images between local storage and remote registries. The project distinguishes itself by supporting unprivileged image building through the use of user namespaces and rootless mode. It enables direct modification of container root filesystems by mounting them to the host, allowing images to be treated as directories that can be manipulated via standard shell commands or scripts.

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

Libpod is a container management library for running and controlling the lifecycle of Open Container Initiative compliant containers and images across different storage backends. It provides a programmatic interface for the remote control and automation of container environments. The project enables the coordination of multiple containers into pods that share network namespaces and other shared resources. It supports rootless container execution by using user namespaces to launch containers without administrative privileges. The library covers a broad range of system operations, including im

ipfs-desktop is a graphical application for managing a local IPFS node, hosting content, and interacting with the peer-to-peer network. It serves as a desktop client that provides a visual interface for content-addressed storage management, peer-to-peer file sharing, and the administration of the node lifecycle. The project differentiates itself by providing a comprehensive suite of controllers for node health, gateway routing, and static site hosting. It includes a dedicated content-addressed storage browser for importing and organizing files, a gateway controller to route network content th

Uncloud is a decentralized container orchestrator designed to deploy and manage applications across multiple servers without a central control plane. It functions as a peer-to-peer system and a Docker Compose cluster deployer, using SSH-based infrastructure management to coordinate operations across remote nodes. The project distinguishes itself by using a secure mesh network overlay to enable direct inter-container communication across different physical machines. It facilitates container image distribution by transferring missing layers directly from local environments to target nodes, bypa

This project serves as a comprehensive reference architecture and a guide to best practices for developing scalable applications with the Spring Boot framework. It provides a structural blueprint for Java backend development, focusing on the implementation of decoupled APIs and the establishment of architectural standards. The project specifically details the creation of custom starters and auto-configuration modules to simplify the integration of third-party libraries. It also provides a deployment blueprint for packaging applications as executable jars and optimizing layered builds for cont

go-containerregistry is a Go library and toolkit for interacting with OCI and Docker registries. It provides a programmatic implementation of the Open Container Initiative distribution specification to fetch, upload, and manage container images, manifests, and layers. The library functions as a container image manipulation tool and a multi-platform image index manager. It enables the resolution and management of manifest lists that target various hardware architectures and operating systems without requiring a local daemon. The toolkit covers a broad range of registry interactions, including

cargo-chef is a Rust build cache tool and CI pipeline accelerator designed to reduce compilation times by decoupling library compilation from application source code. It functions as a dependency recipe generator that extracts a project's dependency list into a recipe for pre-compilation without requiring the full source tree. The project optimizes Docker image builds by structuring container layers to store pre-computed build artifacts. This prevents full recompilation of dependencies when only application source code changes, ensuring that dependency updates only trigger necessary rebuilds.

Inspektor Gadget is an eBPF observability toolset and program framework designed for tracing Linux systems and debugging Kubernetes nodes. It provides a suite of tools to collect kernel-level telemetry and export system metrics via the OpenTelemetry standard. The project distinguishes itself by packaging inspection tools as OCI-compliant container images, allowing for standardized distribution and deployment across clusters and hosts. It employs a modular data processing pipeline that utilizes WebAssembly modules to transform and filter telemetry, and leverages Compile Once Run Everywhere for

go-ipfs is an implementation of an IPFS node, providing a distributed filesystem and a content-addressable storage system. It enables the storage and retrieval of data based on unique cryptographic hashes rather than fixed network locations, allowing files to be shared across a peer-to-peer network without a central authority. The system utilizes a distributed hash table and a peer-to-peer gossip protocol to route requests and propagate network state and metadata. It organizes data using a Merkle DAG structure to support efficient deduplication and versioning of content. Capabilities include

Afero is a Go library that provides a unified filesystem abstraction, allowing applications to interact with local disk, in-memory storage, cloud services, archives, and remote systems through a single, consistent interface. At its core, it defines a standard interface that all filesystem backends implement, enabling developers to swap storage implementations without changing application code. The library distinguishes itself through its composable architecture, which includes layered filesystem composition for creating cached, sandboxed, or restricted storage views. It offers a copy-on-write

Noms is a distributed version control database and content-addressable data store. It identifies data by cryptographic hashes to ensure integrity and deduplication, while tracking dataset state changes through a sequence of immutable commits to enable branching, forking, and historical recovery. The system functions as a peer-to-peer data synchronizer, reconciling state between disconnected database instances to ensure all nodes converge on the same data. It distinguishes itself as a schema-flexible document store that supports self-describing types, allowing schemas to evolve and widen as ne

Git is a distributed version control system and command-line tool designed for tracking changes in source code and coordinating collaborative software development. It functions as a content-addressable storage platform where project data is maintained as immutable objects indexed by cryptographic hashes, ensuring data integrity and efficient deduplication. The system organizes project history as a directed acyclic graph, where each commit serves as a snapshot linked to its parent to create a verifiable timeline of modifications. The architecture distinguishes itself through an index-based sta

This project provides a comprehensive implementation of the AT Protocol, serving as a framework for building decentralized social networking applications. It enables the creation of distributed data repositories where users maintain cryptographic ownership of their identity and content, allowing for portable accounts that can be migrated between independent servers without central authority intervention. The platform distinguishes itself by decoupling content hosting from discovery through modular algorithmic curation. Users can select third-party services to filter and organize their feeds,

js-git is a modular JavaScript implementation of the Git protocol and object model. It provides a content-addressable storage engine that manages blobs, trees, and commits using cryptographic hashes, allowing version control functionality to operate without external system dependencies. The project features a pluggable repository interface and storage layer, enabling Git data to be persisted across diverse mediums such as browser databases or local file systems. It includes a streaming packfile processor for packing and unpacking objects to facilitate efficient data transfer. The library cov

Entropic is a language-agnostic package registry and distribution system that uses content-addressable storage to host and version software packages across a network of mirrors. It functions as both a private package registry and a JavaScript package manager, identifying assets by cryptographic hashes rather than file paths. The system focuses on reliable distribution through private package mirrors that cache and sync remote dependencies to prevent installation failures during external downtime. It includes a version manager for assigning distribution tags and controlling the software releas

Indigo is a Go-based framework and toolkit designed for building, hosting, and scaling services within the AT Protocol ecosystem. It provides the foundational infrastructure for decentralized social networking, enabling developers to implement relay services, manage cryptographically signed user repositories, and handle identity resolution across federated environments. The project distinguishes itself through a robust architecture that decouples content hosting from discovery, allowing for independent moderation and algorithmic feed generation. It utilizes content-addressed storage and Merkl

Buck2 is a programmable monorepo build tool and hermetic build system designed to manage large-scale projects with complex target graphs and multi-language dependencies. It functions as a remote execution framework and dependency graph analyzer, providing an artifact caching engine to ensure reproducible and consistent build results across different environments. The system distinguishes itself through an incremental computation engine that recomputes only the specific nodes in a dependency graph invalidated by changes. It utilizes content-addressable storage for build artifact caching and su