moby

Moby is the open-source project, created by Docker, that provides the toolkit components used to build container-based systems. Rather than shipping as one monolithic product, it's organized as a set of modular pieces (container build tools, a registry, orchestration tools, a runtime, and more) that can be assembled together or swapped out individually. It's aimed at engineers, integrators, and enthusiasts who want to work directly with the open-source building blocks behind Docker Engine, whether to contribute upstream, build a custom container system, or simply understand what's underneath the Docker product they use daily.

Key features

• Modular components: well-defined components with clear functions and APIs that work together, so pieces can be combined or replaced depending on what you're building.
• Batteries included but swappable: enough components ship to build a fully featured container system out of the box, but the modular architecture means most pieces can be swapped for different implementations.
• Usable security defaults: secure defaults are provided without sacrificing day-to-day usability.
• Developer-focused APIs: the APIs are built to be functional building blocks for other tools, not polished end-user interfaces, and the documentation reflects that audience.
• Go client and API modules: github.com/moby/moby/client provides a Go client for the Docker Engine API, and github.com/moby/moby/api provides the shared API types between client and server, both versioned independently from the root module.
• Upstream for Docker Engine: Docker is committed to using Moby as the upstream for the Docker product, and the releases in this repository are tagged with a docker- prefix (for example docker-v29.0.0).
• Open governance: the project is open to the community to help set its direction, with external maintainers and contributors welcomed.

Ideal use cases

Moby is the right layer to work with if you're building or modifying a container engine itself, contributing to the open-source code that underpins Docker, or integrating the Docker Engine API into a Go application via the client and api modules. It's also useful reading for anyone trying to understand how container build, runtime, and registry pieces fit together at a lower level than the Docker CLI exposes.

It is explicitly not intended as a place to get commercial support or file feature requests for the Docker product. The README is direct about this: Moby is for contributors working on open-source code, not for support, and the releases here are supported by maintainers and the community on a best-efforts basis only. If you want commercially supported container tooling, Docker Desktop or Mirantis Container Runtime are the intended products for that. Similarly, if you just want to run containers day to day, installing Docker Engine directly is more appropriate than working with Moby's source.

Installation

Moby's root module builds binaries (such as the Docker Engine binary); it is explicitly not intended to be imported as a Go library and carries no API stability guarantees for that root module. If you need to build container engine binaries from this source, the release tags (prefixed docker-, e.g. docker-v29.0.0) mark the versions used for that build.

For applications that just need to talk to the Docker Engine API from Go, the supported path is importing the versioned client and API modules directly:

import "github.com/moby/moby/client"
import "github.com/moby/moby/api/types"

If migrating from the older github.com/docker/docker import paths (deprecated starting with Docker v29), replace them accordingly:

- import "github.com/docker/docker/client"
+ import "github.com/moby/moby/client"

- import "github.com/docker/docker/api/types"
+ import "github.com/moby/moby/api/types"

Note that v29 introduced breaking API changes (option structs, renamed methods, moved types), so migrating an existing integration is not a drop-in path; the v29.0.0 release notes document the full list of Go SDK changes.