Skip to content
CAI
Software that uses CAICheck a score

GoogleContainerTools/jib

67.0

Adequate · 13 November 2026

38k

lines of production code

Java

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Jib is a daemonless container-building tool for Java applications that integrates with Maven, Gradle, and a standalone CLI to create optimized container images. It supports various Java frameworks and artifact types, including Spring Boot, WARs, and multi-module projects, while providing a programmatic API for precise control over image layers and configuration. The system handles registry authentication, caching, and reproducible builds, and includes extensions for Skaffold integration and third-party customization.

How it got here

2017–2018 — Core architecture refactoring and API stabilization

81 changes.

This period focused on a comprehensive restructuring of the Jib core library, introducing a modular step-based build pipeline, a new Blob abstraction, and a robust HTTP client framework. The team established a stable public API for programmatic containerization while enhancing reproducibility through deterministic layer building and improved cache storage with corruption detection. Concurrently, the project formalized its community governance, integrated Kokoro CI, and expanded support for various Java frameworks through updated examples and plugin configurations.

2019–2020 — CLI introduction and extension API

51 changes.

This period focused on introducing a new Jib CLI with YAML-based build configuration and packaged/exploded JAR processing modes. It also established a plugin extension API for both Maven and Gradle, allowing third-party customization of the build plan, alongside significant expansion of integration test coverage across all modules.

2021–2022 — CLI enhancements and global config support

9 changes.

This period focused on expanding the Jib CLI with support for containerizing WAR files via exploded mode and improving version reporting. It also introduced global registry mirror configuration capabilities and added corresponding test coverage and release infrastructure scripts.

Features

Add Dropwizard example application

An initial Dropwizard-based example project has been added to the examples directory, providing a reference implementation for building and containerizing Java applications using Jib. This includes a REST resource that returns a templated greeting message, demonstrating how to integrate Dropwizard with Jib for cloud deployment.

dropwizard-jib-example · high confidence

Add Dropwizard example with Jib and FreeMarker templating

The Dropwizard example project is introduced, demonstrating how to containerize a Dropwizard application using Jib. The example includes a Maven wrapper (version 3.6.0) and a FreeMarker-based configuration bundle that allows runtime customization of application properties (such as health check templates and log levels) via environment variables. It also features a 'Run on Google Cloud' button in the README for direct deployment to Cloud Run.

examples/dropwizard · high confidence

Add Eclipse Vert.x example

A new example demonstrating how to containerize an Eclipse Vert.x application with Jib has been added to the examples/vertx directory. This includes a README with build and run instructions, a Gradle wrapper configured for Gradle 5.1, and a logback configuration for the application.

examples/vertx · high confidence

Add Java Hello World example with Gradle and Maven support

A new Java-based example project has been added to the examples directory. It includes a simple application that prints 'Hello world', along with build configurations for both Maven (using the Jib plugin) and Gradle (version 5.1). The project also includes the necessary Gradle wrapper scripts and a README with instructions for building the container image.

examples/helloworld · high confidence

Add Ktor example application with Jib containerization

This change introduces a new example project in the \examples/ktor\ directory that demonstrates how to build and containerize a Ktor application using Jib. The example includes a Gradle wrapper configured for Gradle 5.1, a Ktor application (\App.kt\) featuring health checks, metrics, and logging, and configuration files for the application and logging. Users can now build a Docker image for this Ktor app using \./gradlew jibDockerBuild\ and run it locally.

examples/ktor · high confidence

Add Micronaut example with Gradle wrapper

Users can now build and containerize a Micronaut application using Jib. This location provides the example source code (a Groovy-based 'Hello World' controller), configuration files, and a Gradle wrapper (minimum version 5.1) to facilitate the build process.

examples/micronaut · high confidence

Add multi-module build example for Maven and Gradle

The \examples/multi-module\ directory now includes a complete example demonstrating how to build multiple containers for a multi-module project using both Maven and Gradle. The example consists of a \shared-library\ module and two microservices (\name-service\ and \hello-service\) that depend on it. It provides build scripts (\maven-build.sh\, \gradle-build.sh\) and wrapper scripts (\mvnw\, \gradlew\) to facilitate building and deploying the services, along with a \kubernetes.yaml\ manifest for running the services on Kubernetes.

examples/multi-module · high confidence

Added ErrorEntryTemplate for parsing registry error responses

A new ErrorEntryTemplate class has been added to the registry JSON package to support deserialization of Docker registry error responses. This class maps the 'code' and 'message' fields from JSON error entries, enabling the application to properly parse and handle specific error conditions returned by the registry.

jib-core/src/main/java/com/google/cloud/tools/jib/registry/json · high confidence

Added Gradle wrapper for the multi-module example

The multi-module Gradle example now includes a Gradle wrapper configuration that pins the build to Gradle 5.1, ensuring consistent builds across environments without requiring a pre-installed Gradle version.

examples/multi-module/gradle · high confidence

Added multi-module example project

A new multi-module example has been added to the examples directory, demonstrating a Spring Boot application structure. This includes a 'hello-service' module containing a REST controller that calls another service ('name-service') via RestTemplate, along with the necessary Maven wrapper configuration to build the project.

examples/multi-module/.mvn, examples/multi-module/hello-service · high confidence

Added release build script for Jib Core

A new shell script (release\_build.sh) has been added to the kokoro directory to automate the release process for Jib Core. This script executes the Gradle task :jib-core:prepareRelease, ensuring that release builds fail on errors and display command traces for debugging.

jib-core/kokoro · high confidence

Added tarball extraction and building utilities

The Jib core library now includes dedicated classes for handling tar archives: TarExtractor allows users to extract tarballs to a destination directory with optional support for reproducible timestamps and symlink preservation, while TarStreamBuilder enables the construction of tar archives with support for long file names and POSIX-compliant big numbers.

jib-core/src/main/java/com/google/cloud/tools/jib/tar · high confidence

Automated GCS latest version update script

A new shell script, update\_gcs\_latest.sh, has been added to the jib-maven-plugin/scripts directory to automate the process of updating the 'latest' version string in Google Cloud Storage. This script accepts a release version as an argument, validates its format, uploads a JSON file containing the version to the gs://jib-versions/jib-maven bucket, configures public read access using the gcloud storage CLI, and verifies the update by comparing the local and remote file contents.

jib-maven-plugin/scripts · high confidence

Automated release build for Jib Maven Plugin

A new Kokoro release script has been added to automate the release preparation process for the Jib Maven Plugin. The script configures the environment to suppress OS-specific warnings in the GCP Ubuntu Docker container and executes the Gradle \prepareRelease\ task for the plugin module.

jib-maven-plugin/kokoro · high confidence

Automated release pipelines for Jib extension modules

Added Kokoro release build scripts for the jib-build-plan, jib-maven-plugin-extension-api, and jib-plugins-extension-common modules. These scripts automate the release preparation process by invoking the respective Gradle \prepareRelease\ tasks, enabling streamlined publishing of these artifacts to Maven Central.

jib-build-plan/kokoro, jib-maven-plugin-extension-api/kokoro, jib-plugins-extension-common · high confidence

Initial Kokoro CI build and presubmit scripts for Jib

Adds Kokoro build scripts (continuous.bat, continuous.sh, presubmit.bat, presubmit.sh) and platform-specific Docker setup helpers (docker\_setup\_macos.sh, docker\_setup\_ubuntu.sh) to automate the Jib project's continuous integration and presubmit testing. The continuous scripts configure Docker credentials via docker-credential-gcr, clean up leftover containers, and run the full Gradle build and integration tests, while the presubmit scripts run a subset of tests (jib-core integration tests) to speed up feedback. Platform-specific setup scripts handle Docker machine configuration for macOS (Big Sur) and Ubuntu environments, including insecure registry settings and authentication setup.

kokoro · high confidence

Introduce Blob abstraction for writing content to output streams

The \jib-core\ module now includes a new \Blob\ package containing the \Blob\ interface, \BlobDescriptor\ for tracking digest and size, and a \Blobs\ utility class to create blobs from inputs, files, JSON, strings, or writable contents. This provides a standardized way to write content to output streams while computing digests, with support for retryable writes in specific implementations like \JsonBlob\ and \WritableContentsBlob\.

jib-core/src/main/java/com/google/cloud/tools/jib/blob · high confidence

Introduce Jib Gradle Plugin Extension API

This release introduces the Jib Gradle Plugin Extension API (version 0.4.0), enabling third-party developers to customize the container build process. The new API provides the \JibGradlePluginExtension\ interface, which allows extensions to define custom configuration types and modify the \ContainerBuildPlan\ via the \extendContainerBuildPlan\ method. It also exposes \GradleData\ to give extensions access to the underlying Gradle \Project\, facilitating deeper integration with Gradle-specific properties and tasks.

jib-gradle-plugin-extension-api · high confidence

Introduce Maven plugin extension API for custom configurations

The Jib Maven plugin now exposes a new extension API (\JibMavenPluginExtension\) that allows third-party extensions to define custom configuration types and modify the container build plan. This interface enables extensions to receive Maven-specific data (via \MavenData\) and apply custom logic to the build process, facilitating deeper integration with Maven projects.

jib-maven-plugin-extension-api/src · high confidence

Introduce YAML-based buildfile configuration for the Jib CLI

The Jib CLI now supports defining container builds via a structured YAML buildfile (apiVersion v1alpha1). This new feature allows users to specify the base image (including multi-platform selections), container metadata (environment variables, labels, volumes, ports, user, working directory, entrypoint, and command), and detailed layer definitions. Layers can be defined as file sets with source/destination paths, include/exclude glob filters, and inherited file properties (permissions, ownership, timestamps), or as archive layers. The system includes validation for required properties and supports templating via variable substitution in the YAML file.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/buildfile · high confidence

Introduce core interfaces and types for the Jib plugin extension API

This change adds the foundational types for the new plugin extension framework in the \jib-plugins-extension-common\ module. It introduces the \JibPluginExtension\ base interface for extension implementations, an \ExtensionLogger\ interface with verbosity levels (ERROR, WARN, LIFECYCLE, INFO, DEBUG) for extension logging, a \JibPluginExtensionException\ to capture errors with their originating extension class, and a \NullExtension\ class to represent invalid or no-op extensions.

jib-plugins-extension-common/src/main/java/com/google/cloud/tools/jib/plugins/extension · high confidence

Introduce new Jib CLI with jar, war, and build commands

The Jib CLI has been replaced with a new implementation featuring dedicated commands for containerizing artifacts. The new \jar\ command supports both packaged and exploded processing modes for standard and Spring Boot JARs, while the \war\ command handles standard WAR files in exploded mode. A new \build\ command allows users to define container configurations via a YAML build file. The CLI now includes options to specify base images, entrypoints, JVM flags, and container metadata, along with support for registry mirrors and HTTP tracing.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli · high confidence

Introduce new Jib Core public API for container building

The \jib-core\ module now exposes a comprehensive public API in the \com.google.cloud.tools.jib.api\ package, enabling programmatic containerization. This includes the \Jib\ and \JavaContainerBuilder\ entry points for configuring base images (registry, Docker daemon, tarball, or scratch) and application layers, the \Containerizer\ for defining build targets and caching behavior, and supporting types like \ImageReference\, \Credential\, and \DockerClient\. This change establishes the primary interface for users to build and push container images from Java applications.

jib-core/src/main/java/com/google/cloud/tools/jib/api · high confidence

Introduce the ContainerBuildPlan API for container image configuration

The build plan module now exposes a new \ContainerBuildPlan\ API that allows users to declaratively define container image properties, including multi-platform support, environment variables, volumes, exposed ports, and entrypoints. The API also introduces explicit models for file layers (\FileEntriesLayer\), file entries (\FileEntry\), and permissions (\FilePermissions\), enabling precise control over file ownership, modification times, and POSIX permissions within the container image.

jib-build-plan/src/main · high confidence

Maven plugin goals are now thread-safe

The Jib Maven plugin goals (build, dockerBuild, buildTar) are now marked as thread-safe, allowing them to be executed concurrently in multi-module Maven builds without risk of race conditions or shared state corruption.

jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven · high confidence

New CLI processors for Spring Boot and standard JARs, plus Vert.x example

The Jib CLI now supports building Spring Boot and standard executable JARs in both exploded and packaged modes via new ArtifactProcessor implementations (SpringBootExplodedProcessor, SpringBootPackagedProcessor, StandardExplodedProcessor, StandardPackagedProcessor), which handle layer creation and entrypoint computation. A new Vert.x example application (MainVerticle) is added to demonstrate usage. These changes are part of the broader CLI JAR command implementation.

jib-maven-plugin/src/test/resources/maven/projects/war\servlet25 · high confidence

New CredentialRetrieverFactory for flexible credential resolution

The new CredentialRetrieverFactory class provides a centralized way to create CredentialRetrievers, supporting known credentials, Docker credential helpers (including well-known ones like docker-credential-gcr for gcr.io), and Google Application Default Credentials. This enables more flexible and robust authentication for container images, particularly for Google Cloud registries.

jib-core/src/main/java/com/google/cloud/tools/jib/frontend · high confidence

New JSON serialization and deserialization utilities

Added JsonTemplate and JsonTemplateMapper classes to provide a standardized way to serialize and deserialize JSON objects using Jackson. JsonTemplate serves as a base interface for JSON templates, ensuring that null fields are not serialized and private fields are accessible. JsonTemplateMapper offers methods to read JSON from files, input streams, strings, and byte arrays, as well as to write JSON templates to output streams. This enhancement simplifies JSON handling within the application, making it easier to work with JSON data structures.

jib-core/src/main/java/com/google/cloud/tools/jib/json · high confidence

New Java Agent example with Cloud Run support

Added a new example demonstrating how to download and configure the Stackdriver Debugger Java Agent for a SparkJava application. The example includes a README with build instructions, Gradle wrapper files (upgrading the minimum Gradle version to 5.1), and source code that dynamically listens on the PORT environment variable to support deployment on Google Cloud Run.

examples/java-agent · high confidence

New Progress and Timer event types for build tracking

Jib now exposes ProgressEvent and TimerEvent to provide detailed visibility into build execution. ProgressEvent reports advancement based on allocation units, allowing users to track work distribution across a decentralized allocation tree. TimerEvent provides timing data with START, LAP, and FINISHED states, including lap durations, total elapsed time, and hierarchical timer support, enabling users to monitor performance and duration of specific build phases.

jib-core/src/main/java/com/google/cloud/tools/jib/event/events · high confidence

New Skaffold integration goals for Maven

The Maven plugin now includes a set of internal Skaffold-binding goals to improve integration with the Skaffold development workflow. These new goals include \\_skaffold-init\ for project detection, \\_skaffold-files-v2\ for listing source and dependency files (with added support for Kotlin source directories), \\_skaffold-sync-map\ for generating file sync maps, \\_skaffold-package-goals\ to identify relevant packaging goals, and \\_skaffold-fail-if-jib-out-of-date\ to enforce minimum Jib plugin versions.

jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/skaffold · high confidence

New Skaffold integration tasks and configuration parameters

The Gradle plugin now includes a new set of internal tasks (\_jibSkaffoldInit, \_jibSkaffoldFilesV2, \_jibSkaffoldSyncMap, and \_skaffoldFailIfJibOutOfDate) to support Skaffold integration. These tasks output JSON data describing the project's build files, source dependencies, and file-to-container mappings. Additionally, the JibExtension now exposes configurable Skaffold parameters, allowing users to define specific file paths for watch includes/excludes and sync excludes via the new SkaffoldWatchParameters and SkaffoldSyncParameters classes.

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/skaffold · high confidence

New filesystem utilities and OS-specific cache/config directory resolution

This change introduces new internal utilities in the jib-core filesystem package: DirectoryWalker for recursive directory traversal, FileOperations for copying files and directories, PathConsumer as a functional interface for path handling, and XdgDirectories to resolve OS-specific cache and configuration locations (Linux XDG, Windows %LOCALAPPDATA%, macOS Library/Caches) for Jib's local storage.

jib-core/src/main/java/com/google/cloud/tools/jib/filesystem · high confidence

New output models for image metadata, Skaffold file watching, and sync maps

The plugin now includes dedicated output classes to structure build artifacts for external tools. ImageMetadataOutput serializes build results (image reference, ID, digest, tags, and push status) into JSON, enabling users to consume structured metadata after a build. SkaffoldFilesOutput generates JSON describing which files and directories Skaffold should watch for changes, while SkaffoldSyncMapTemplate produces JSON mapping local source files to their destinations in the container, supporting both direct and generated sync entries. Additionally, PluginExtensionLogger provides a standardized logging interface for plugin extensions.

jib-plugins-common/src/main · high confidence

New script to update Jib CLI latest version in GCS

A new shell script, update\_gcs\_latest.sh, has been added to the jib-cli/scripts directory. This script accepts a release version as an argument, validates its format, and uploads a JSON file containing the latest version to the gs://jib-versions/jib-cli Google Cloud Storage bucket. It configures the object to be publicly readable and verifies the upload by comparing the remote content against the local version string, ensuring the CLI can correctly resolve the latest available version.

jib-cli/scripts · high confidence

New utility classes for computing content digests

Added three new classes in the \jib.hash\ package to support digest computation: \CountingDigestOutputStream\ tracks bytes written while computing a SHA-256 hash, \WritableContents\ provides a functional interface for writing content to an output stream, and \Digests\ offers static utility methods to compute digests for JSON templates and input streams while optionally copying data to an output stream.

jib-core/src/main/java/com/google/cloud/tools/jib/hash · high confidence

Support for containerizing WAR files via exploded mode

The Jib CLI now supports building containers from WAR files. This change introduces an exploded-mode processor that unpacks the WAR archive and organizes its contents into distinct image layers (dependencies, snapshots, classes, and resources). It also provides a default entrypoint configuration optimized for Jetty 12 and later, ensuring the container starts correctly with the necessary deployment modules.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/war · high confidence

Support for global registry mirror configuration

Jib now reads a global configuration file (config.json) that allows users to define registry mirrors. This change introduces a new global config structure that parses and validates a 'registryMirrors' section, mapping specific registries to their mirror endpoints, alongside an existing 'disableUpdateCheck' option. Users can now configure these mirrors globally via the config file or system properties, enabling consistent image pull-through behavior across projects without per-plugin configuration.

jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/globalconfig · high confidence

Architecture

Refactored build configuration into dedicated context and image classes

The build configuration logic in jib-core has been reorganized into specific, immutable configuration classes to improve clarity and maintainability. BuildContext now serves as the central hub for the builder process, managing static options and execution services like caching, event handling, and HTTP clients. ImageConfiguration has been introduced to encapsulate base and target image details, including credential retrieval strategies and support for local Docker daemon or tarball sources. ContainerConfiguration now holds all container-specific settings, such as platform selection, environment variables, exposed ports, volumes, and labels. Additionally, DockerHealthCheck provides a dedicated structure for defining container health checks with configurable intervals, timeouts, and retry policies.

jib-core/src/main/java/com/google/cloud/tools/jib/configuration · high confidence

Refactored build execution into a new modular step-based architecture

The build process in jib-core has been restructured from a monolithic execution model into a modular pipeline of distinct builder steps located in the \jib.builder.steps\ package. This change introduces specific components for each phase of the build lifecycle, including \AuthenticatePushStep\ for registry authentication, \BuildAndCacheApplicationLayerStep\ for creating and caching application layers, \PullBaseImageStep\ and \LocalBaseImageSteps\ for retrieving base images from registries or the local Docker daemon, and \BuildImageStep\ for assembling the final container image. The new architecture also includes \BuildManifestListOrSingleManifestStep\ for generating manifests, \CheckManifestStep\ to verify existing images, and \LoadDockerStep\ for loading images into the Docker daemon. This refactoring standardizes the build flow, improves progress reporting via \ProgressEventDispatcher\, and supports advanced features like multi-platform builds and selective layer downloads.

jib-core/src/main/java/com/google/cloud/tools/jib/builder/steps · high confidence

Behavioural changes

Automated Gradle plugin publishing and GCS version tracking

The release workflow now includes dedicated shell scripts to automate the publishing of the Jib Gradle plugin to Maven Central and to update the latest version string in Google Cloud Storage. The new release.sh script handles authentication via Kokoro secrets and executes the Gradle publish task, while update\_gcs\_latest.sh validates version formats, uploads the version metadata to gs://jib-versions/jib-gradle, and configures public read access using the gcloud storage CLI.

jib-gradle-plugin/scripts · high confidence

Centralized system property definitions and validation

Jib now defines all system property names (such as jib.httpTimeout, jib.blobMounts, jib.serialize, sendCredentialsOverHttp, and jib.skipExistingImages) in a single JibSystemProperties class. This centralization ensures consistent usage across the codebase and adds validation for numeric properties like httpTimeout and proxy ports, improving reliability for users configuring Jib via system properties.

jib-core/src/main/java/com/google/cloud/tools/jib/global · high confidence

Centralizes Jib project metadata constants

A new ProjectInfo class has been added to store constants for the Jib project, specifically defining the GitHub repository URL and the link to file new issues. This change centralizes these metadata values, ensuring consistency across the codebase and simplifying updates to the project's online resources.

jib-core/src/main/java/com/google/cloud/tools/jib · high confidence

Core image model and reproducible layer building refactored

The image-building core in jib-core has been restructured to support reproducible builds and OCI/Docker tarball export. A new immutable Image model and Layer interface replace previous structures, introducing specific layer types like DigestOnlyLayer, ReferenceLayer, and ReferenceNoDiffIdLayer to handle layers with or without content and diff IDs. The ImageTarball class now explicitly generates both OCI and Docker format tarballs. Additionally, the ReproducibleLayerBuilder ensures deterministic output by stripping non-reproducible metadata (timestamps, UIDs, GIDs) from tar entries and enforcing consistent file permissions and ownership.

jib-core/src/main/java/com/google/cloud/tools/jib/image · high confidence

Disables Apache Commons Logging output

A new \commons-logging.properties\ file has been added to the resources directory to configure the Apache Commons Logging framework. By setting \org.apache.commons.logging.Log\ to \org.apache.commons.logging.impl.NoOpLog\, the application now suppresses all logging output from this library, preventing unnecessary log noise in the console or logs.

jib-core/src/main/resources · high confidence

Gradle plugin configuration model refactored to use Gradle Properties and Providers

The Jib Gradle plugin's configuration API has been rewritten to leverage Gradle's Property and Provider types (lazy evaluation). This introduces new parameter classes (such as AuthParameters, BaseImageParameters, ContainerParameters, and ExtraDirectoriesParameters) that replace the previous configuration beans. For users, this means the plugin now supports lazy configuration for properties like mainClass, jvmFlags, and extraDirectories, which improves build performance and allows for more flexible, deferred evaluation of configuration values.

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle · high confidence

Improved Docker credential helper resolution and error handling

The credential retrieval logic now supports environment variables for configuring credential helpers and attempts to locate the helper executable with .cmd and .exe extensions on Windows. Additionally, the system distinguishes between missing helper executables and missing credentials for a specific server URL, providing clearer error messages when authentication fails.

jib-core/src/main/java/com/google/cloud/tools/jib/registry/credentials · high confidence

Internal event handling implementation refactored

The internal event dispatching mechanism has been refactored to improve encapsulation. A new internal Handler class has been introduced to manage event consumption, and the public EventEmitter interface has been renamed to EventDispatcher. These changes adjust the internal structure of the event system without altering the external API surface.

jib-core/src/main/java/com/google/cloud/tools/jib/event · medium confidence

Jib CLI now displays the correct version number

The Jib CLI now correctly reports its version when queried (e.g., via the --version flag). This is achieved by introducing a new VersionInfo class that implements picocli's IVersionProvider interface, which retrieves the version string from a template variable during the build process.

jib-cli/src/java-templates · high confidence

New HTTP client framework with progress tracking and configurable timeouts

This change introduces a new HTTP client implementation in the \jib-core\ module, replacing the previous infrastructure. The new framework adds support for tracking upload progress via \BlobHttpContent\ and \NotifyingOutputStream\, which report byte counts to listeners. It also introduces configurable HTTP timeouts through the \Request\ builder and a new \Authorization\ class to manage Basic and Bearer credentials. Additionally, \ResponseException\ now exposes whether the authorization header was cleared during a request, aiding in debugging authentication flows.

jib-core/src/main/java/com/google/cloud/tools/jib/http · high confidence

New JAR processing modes and default base images in Jib CLI

The Jib CLI now supports 'packaged' and 'exploded' processing modes for JAR files, allowing users to control how application layers are structured in the resulting container image. Additionally, the default base images have been updated to Eclipse Temurin for Java versions 8, 11, 17, 21, and 25, replacing previous defaults like AdoptOpenJDK. These changes are implemented in the new JarFiles, JarLayers, and ProcessingMode classes, which handle layer creation, dependency resolution, and base image selection for JAR-based containers.

jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar · high confidence

New cache storage engine with corruption detection and retry logic

The cache module introduces a new storage engine implementation that includes a \CacheCorruptedException\ to provide clear guidance when the cache directory is invalid, a \Retry\ utility to handle transient file-system errors (such as Windows antivirus interference) during cache writes, and a \LayerEntriesSelector\ that incorporates file modification times, permissions, and ownership into cache key generation to improve cache hit accuracy.

jib-core/src/main/java/com/google/cloud/tools/jib/cache · high confidence

New progress reporting infrastructure with throttled callbacks

The progress event system in jib-core has been refactored to introduce a new \ProgressEventHandler\ that tracks allocation completion and accumulates overall progress, notifying consumers via a callback. To prevent UI or log flooding, progress updates are now throttled using \ThrottledAccumulatingConsumer\, which merges rapid successive calls into a single notification after a 100ms delay. This change ensures that users receive consolidated progress updates rather than a stream of individual events, improving performance and readability of build progress.

jib-core/src/main/java/com/google/cloud/tools/jib/event/progress · high confidence

The logging subsystem in jib-plugins-common has been restructured to support rich, ANSI-enabled console output with a dynamic progress footer. A new ConsoleLogger interface and builder allow plugins to configure log consumers for different levels (lifecycle, progress, debug, etc.). The AnsiLoggerWithFooter implementation manages a bold progress footer that updates in place using ANSI cursor control sequences, with lines truncated to a maximum width of 50 characters to prevent display issues on narrow terminals. A PlainConsoleLogger provides a fallback for non-ANSI environments by stripping color codes. Progress display generation is handled by ProgressDisplayGenerator, which formats the progress bar and list of unfinished tasks. All logging operations are serialized via a SingleThreadedExecutor to ensure deterministic output order.

jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/logging · high confidence

Refactored image manifest and container configuration JSON handling

The JSON serialization and deserialization logic for Docker and OCI image manifests and container configurations has been restructured. New template classes (such as BuildableManifestTemplate, ContainerConfigurationTemplate, and HistoryEntry) and dedicated translators (ImageToJsonTranslator, JsonToImageTranslator) now manage the conversion between internal image models and JSON formats. This change introduces support for OCI manifest schemas alongside existing Docker V2.2/V2.1 formats, adds handling for container health checks, and improves the parsing of image creation timestamps with time offsets.

jib-core/src/main/java/com/google/cloud/tools/jib/image/json · high confidence

Refactored plugin configuration and credential handling into jib-plugins-common

The \jib-plugins-common\ module now centralizes core plugin logic, introducing a new \DefaultCredentialRetrievers\ class that standardizes the order and sources for authentication (checking known credentials, credential helpers, Docker config files, and well-known helpers). Configuration validation and parsing are now handled by \ConfigurationPropertyValidator\, which supports escaped comma-separated properties and generates default Docker tags. The module also adds support for WAR containerization via \JavaContainerBuilderHelper.fromExplodedWar\ and allows users to configure extra directory inclusion/exclusion patterns and file permissions. These changes provide a unified foundation for Maven and Gradle plugin configuration and build execution.

jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common · high confidence

Refactored registry client into a modular endpoint provider architecture

The registry communication layer in jib-core has been restructured to use a new provider-based design. This introduces dedicated classes for specific registry operations, including BlobChecker and BlobPuller for layer handling, ManifestChecker, ManifestPuller, and ManifestPusher for manifest operations, and a centralized RegistryEndpointCaller to manage HTTP requests. The change also adds support for Docker Hub alias resolution via RegistryAliasGroup, introduces typed error codes in ErrorCodes, and provides a ManifestAndDigest container to return both manifest data and its digest together.

jib-core/src/main/java/com/google/cloud/tools/jib/registry · high confidence

Repository rebranding to Jib and addition of community governance documents

The project has been renamed from 'Minikube build tools for java' to 'Jib', with the README updated to reflect its role as a daemonless container-building tool for Java applications via Maven, Gradle, and a core library. This change introduces new repository-level governance files: a Code of Conduct to foster an open community, a Security Policy outlining supported versions and vulnerability reporting via Google's vulnerability intake, and a Style Guide defining Java coding standards. Additionally, the Gradle wrapper scripts (gradlew, gradlew.bat) and .gitignore are added/updated to support the unified Gradle build system.

(repo-wide) · high confidence

Spring Boot example now uses Gradle 5.1 and includes wrapper scripts

The Spring Boot example in the \examples/spring-boot\ directory has been updated to require Gradle 5.1 or higher, replacing the previous version. To ensure consistent builds across environments, the example now includes Gradle wrapper scripts (\gradlew\, \gradlew.bat\) and configuration files (\gradle/wrapper/gradle-wrapper.properties\). Additionally, Maven wrapper scripts (\mvnw\, \mvnw.cmd\) and properties have been added to support building with Maven 3.5.4. The example application code remains a simple Spring Boot controller returning "Greetings from Spring Boot and Jib!".

examples/spring-boot · high confidence

Structured progress and timing events for builds

The build process now emits structured progress and timing events via new dispatcher classes. ProgressEventDispatcher manages build allocation units to emit accurate ProgressEvents, replacing manual management, while TimerEventDispatcher tracks execution intervals and emits TimerEvents (start, lap, finished) to provide detailed timing information for build steps.

jib-core/src/main/java/com/google/cloud/tools/jib/builder · high confidence

Support for username, password, and identity token in Docker config authentication

The Docker config credential parser now supports extracting \username\, \password\, and \identityToken\ fields from the \.docker/config.json\ \auths\ section, in addition to the existing base64-encoded \auth\ field. This allows Jib to correctly authenticate with registries that rely on explicit username/password credentials or identity tokens (such as Azure) rather than legacy base64 auth strings, while continuing to ignore unknown properties to ensure robustness against varying config formats.

jib-core/src/main/java/com/google/cloud/tools/jib/registry/credentials/json · high confidence

Updated war\_servlet25 integration test to use Jakarta Servlet API

The war\_servlet25 integration test resource has been updated to import and extend classes from the \jakarta.servlet\ package (e.g., \HttpServlet\, \HttpServletRequest\) instead of the legacy \javax.servlet\ namespace. This change aligns the test sample with the modern Jakarta EE namespace while retaining the Servlet 2.5 web descriptor configuration for backward compatibility testing.

_jib-gradle-plugin/src/integration-test/resources/gradle/projects/war\servlet25 · high confidence

Fixes

Support for Docker manifest JSON with LayerSources and RepoTags

Jib now correctly parses Docker manifest JSON files that include the \LayerSources\ field (introduced in recent Docker versions) and properly handles the \RepoTags\ property. This change ensures compatibility with the latest Docker image formats when loading images, preventing parsing errors for manifests that contain these specific fields.

jib-core/src/main/java/com/google/cloud/tools/jib/docker · high confidence

Test coverage

Add Gradle plugin integration tests for new project types and layer configuration; Add test resources for class-finder edge cases; Added Spring Boot integration test resources; Added empty dependency stubs for integration testing; Added emptyFile test resource for Docker executable path tests; Added exploded-war test resources for plugin testing; Added integration test resources for extra directory configuration; Added integration test resources for local base image support; Added integration tests for Docker credential helper; Added integration tests for JAR and WAR CLI commands; Added integration tests for Jib API containerization and multi-platform builds; Added integration tests for Maven plugin build goals; Added multi-module Maven test fixtures; Added multi-service test fixture resources; Added test coverage for Skaffold integration Mojos; Added test coverage for plugin configuration and credential handling; Added test fixture for Servlet 2.5 WAR with Jakarta dependencies; Added test fixtures for Jib CLI buildfile parsing and layer configuration; Added test fixtures for multi-service Gradle project; Added test helper utilities for HTTP requests and JibContainerBuilder; Added test infrastructure for multithreaded operations; Added test resource for Docker image configuration cache; Added test resource for Servlet 2.5 WAR with Tomcat 10 and Jakarta EE 9+ dependencies; Added test resource for platform dependency handling; Added test resources for Docker config parsing and OCI/Docker manifest formats; Added test resources for Gradle application plugin integration tests; Added test resources for Jib CLI WAR exploded mode; Added test resources for Maven application build scenarios; Added test resources for core and plugin integration tests; Added test resources for core tarball extraction tests; Added test resources for extra directories and file timestamp verification; Added test resources for lazy evaluation scenarios; Added test resources for multi-module Spring Boot project; Added test resources for standard JAR explode mode; Added test resources for webapp structure; Added test service provider for DockerClient; Added test utilities for Jib CLI API testing; Added tests for CountingDigestOutputStream; Added tests for CredentialRetrieverFactory credential retrieval logic; Added tests for Docker client implementation and manifest parsing; Added tests for Docker config credential retrieval and helper behavior; Added tests for EventHandlers event dispatching; Added tests for Jib CLI buildfile specification parsing; Added tests for Jib system properties validation; Added tests for JsonTemplateMapper JSON serialization and deserialization; Added tests for Skaffold integration tasks; Added tests for TarExtractor and TarStreamBuilder; Added tests for WAR exploded-mode processing and container builder configuration; Added tests for builder progress and timer event dispatchers; Added tests for filesystem utilities; Added tests for global Jib configuration reading; Added tests for image JSON serialization and manifest handling; Added tests for logging components; Added tests for progress tracking and event handling; Added tests for the new HTTP framework and failover client; Added unit tests for CLI logging behavior; Added unit tests for JAR CLI processing logic; Added unit tests for Jib CLI components; Added unit tests for LogEvent and ProgressEvent; Added unit tests for Maven plugin configuration and integration utilities; Added unit tests for build plan API components; Added unit tests for builder step components; Added unit tests for configuration classes; Added unit tests for image layer and tarball construction; Added unit tests for the Blob class; Added unit tests for the Gradle plugin configuration and extension system; Added unit tests for the Jib cache subsystem; Added unit tests for the jib-core API layer; Added unit tests for the registry client framework; Configured Mockito to use inline mock maker for tests; Configures Mockito inline mock maker for tests; Expanded integration test coverage for Maven plugin configurations; New integration test utilities and configuration; New integration tests for registry client operations; Updated mock Docker script for integration tests.

Dependencies

The project now includes a checkstyle configuration that enforces Apache 2.0 license headers on Java files and defines specific suppression rules. These suppressions relax certain style checks (such as indentation, line length, and Javadoc requirements) to accommodate existing code patterns, third-party libraries like jib-core, and Gradle plugin parameters, ensuring smoother code quality checks without requiring immediate refactoring of all affected files.

config · high confidence

Update example projects to Jib plugin version 3.5.4

The example projects (helloworld, java-agent, ktor, micronaut, multi-module, spring-boot, and vertx) have been updated to use the Jib Gradle plugin version 3.5.4. This ensures that users following these examples will use the latest stable plugin version for containerizing their Java applications.

(dependencies) · high confidence

Upgraded Gradle wrapper to version 6.9.2

The project now uses Gradle 6.9.2 for builds, as defined in the newly created gradle-wrapper.properties file. This ensures consistent build environments across development and CI systems by pinning the wrapper distribution URL to the specific 6.9.2 binary.

gradle · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 65 → 67 (+2.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 88 → 88 (+0.0)
  • Architecture 92 → 92 (+0.2)
  • Maturity 60 → 56 (-4.1)
  • Readiness 71 → 77 (+5.4)
  • Security 79 → 72 (-7.0)

Resolved (4)

  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Low cohesion: ConsoleLoggerBuilder (LCOM4 6) (jib-plugins-common/src/main/java/com/google/cloud/tools/jib/plugins/common/logging/ConsoleLoggerBuilder.java)
  • No ADRs found
  • Off-boarding risk: anonymized user #1

New (273)

  • Dependency hygiene PARTLY measured — Gradle build resolved part of the dependency graph, currency reported but not scored
  • Edited copies of one member (3 members, 109+ corresponding lines) (jib-maven-plugin/src/main/java/com/google/cloud/tools/jib/maven/BuildDockerMojo.java)
  • Edited copies of one member (3 members, 12+ corresponding lines) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/JibCli.java)
  • Edited copies of one member (3 members, 57+ corresponding lines) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Build.java)
  • Edited copies of one member (3 members, 90+ corresponding lines) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/BuildDockerTask.java)
  • Edited copies of one member (4 members, 22+ corresponding lines) (jib-core/src/main/java/com/google/cloud/tools/jib/builder/steps/StepsRunner.java)
  • Edited copy of a member (10 corresponding lines) (jib-core/src/main/java/com/google/cloud/tools/jib/image/json/OciIndexTemplate.java)
  • Edited copy of a member (11 corresponding lines) (jib-core/src/main/java/com/google/cloud/tools/jib/tar/TarExtractor.java)
  • Edited copy of a member (11 corresponding lines) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/ContainerParameters.java)
  • Edited copy of a member (12 corresponding lines) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/CommonCliOptions.java)
  • Edited copy of a member (12 corresponding lines) (jib-core/src/main/java/com/google/cloud/tools/jib/api/JibContainer.java)
  • Edited copy of a member (13 corresponding lines) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/GradleProjectProperties.java)
  • Edited copy of a member (13 corresponding lines) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/GradleProjectProperties.java)
  • Edited copy of a member (14 corresponding lines) (jib-build-plan/src/main/java/com/google/cloud/tools/jib/api/buildplan/FileEntry.java)
  • Edited copy of a member (16 corresponding lines) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/Containerizers.java)
  • Edited copy of a member (17 corresponding lines) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/StandardExplodedProcessor.java)
  • Edited copy of a member (18 corresponding lines) (jib-core/src/main/java/com/google/cloud/tools/jib/registry/BlobChecker.java)
  • Edited copy of a member (18 corresponding lines) (jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/JibPlugin.java)
  • Edited copy of a member (20 corresponding lines) (jib-core/src/main/java/com/google/cloud/tools/jib/cache/CacheStorageWriter.java)
  • Edited copy of a member (21 corresponding lines) (jib-cli/src/main/java/com/google/cloud/tools/jib/cli/jar/JarFiles.java)
  • …and 253 more

Architecture

  • Containers 0 added · 0 removed · contexts 3 added · 1 removed · edges 5 added · 4 removed

Added bounded contexts (3)

  • jib-cli
  • jib-core
  • vertx-jib-example

Removed bounded contexts (1)

  • jib-maven-plugin/src/test/resources/maven/projects/war_servlet25

Added dependency edges (5)

  • jib-cli → jib-core
  • jib-cli → jib-plugins-common
  • jib-gradle-plugin → jib-core
  • jib-maven-plugin → jib-core
  • jib-plugins-common → jib-core (coupling)

Removed dependency edges (was a dependency, now gone) (4)

  • jib-gradle-plugin → jib-maven-plugin/src/test/resources/maven/projects/war_servlet25 (coupling)
  • jib-maven-plugin → jib-maven-plugin/src/test/resources/maven/projects/war_servlet25 (coupling)
  • jib-maven-plugin/src/test/resources/maven/projects/war_servlet25 → jib-plugins-common
  • jib-plugins-common → jib-maven-plugin/src/test/resources/maven/projects/war_servlet25 (coupling)

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

GoogleContainerTools/jib was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit a600d359769be6fc93aa9f1063d74ee9f09b7184 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.