Skip to content
CAI
Software that uses CAICheck a score

coil-kt/coil

56.5

Adequate · 13 November 2026

20.7k

lines of production code

Kotlin

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add ByteBufferMetadata to expose underlying buffer

Users can now access the raw underlying ByteBuffer of an image source via the new ByteBufferMetadata class, which is exposed as experimental API.

coil-core/src/jvmCommonMain/kotlin/coil3/decode · high confidence

Add Compose Multiplatform sample app

A new Compose Multiplatform sample application has been added to the repository, demonstrating image loading with Coil across Android, iOS, JVM, JS, and Wasm targets. The app features a Material 3 UI with adaptive image grids, handles platform-specific insets and back navigation, and includes resource symlinks for shared assets.

samples/compose · high confidence

Add FileMapper for converting File objects to file URIs

A new FileMapper class has been added to the coil3.map package to handle the mapping of java.io.File instances to Uri objects. This mapper constructs a file scheme URI using the file's path, enabling the library to correctly process local file resources.

coil-core/src/jvmCommonMain/kotlin/coil3/map · high confidence

Add HTTP Cache-Control support for image caching

The new \coil-network-cache-control\ module introduces a \CacheControlCacheStrategy\ that enables Coil to respect HTTP \Cache-Control\ headers (such as \max-age\, \no-cache\, and \immutable\) when deciding whether to serve cached images or fetch new ones. This implementation, based on OkHttp's caching logic, allows applications to leverage server-side cache directives for more efficient image loading and reduced network usage.

coil-network-cache-control/src/commonMain · high confidence

Add Ktor 3 network integration for Coil 3

This change introduces the \coil-network-ktor3\ module, providing a new network fetcher implementation built on Ktor 3. It includes the \KtorNetworkFetcher\ and its factory functions, allowing users to configure HTTP clients with optional cache strategies, connectivity checks, and concurrent request strategies. The module registers itself via ServiceLoader on JVM, JS, Native, and WasmJS platforms, enabling automatic discovery of the Ktor 3 network client within the Coil image loading pipeline.

coil-network-ktor3/src · high confidence

Add internal macro-benchmark suite for startup and scrolling performance

The internal/benchmark module now includes a new set of macro-benchmark tests to measure application startup and scrolling performance. This suite introduces a BaselineProfileBenchmark to compare compilation modes (None, Partial with Baseline Profile, and Full), a BaselineProfileGenerator to create baseline profiles by interacting with the sample app, and a ScrollBenchmark that measures frame timing and specific trace sections (such as image painting) during list scrolling. These changes provide internal visibility into performance characteristics under different compilation and runtime conditions.

internal/benchmark · high confidence

Add native platform implementations for image decoding and weak references

This change introduces native-specific implementations for the Coil image library. It adds a new SkiaImageDecoder for native platforms that delegates bitmap decoding to a synchronous function, and implements a WeakReference utility using Kotlin/Native's native reference API. These additions provide the necessary platform-specific code to support image processing and memory management on native targets.

coil-core/src/nativeMain · high confidence

Add non-Android request service and crossfade support

Introduces platform-specific implementations for non-Android environments, including a new NonAndroidRequestService that handles request delegation, option updates, and cache validation, and adds crossfade animation support for image requests and loaders via dedicated builder extensions and property accessors.

coil-core/src/nonAndroidMain/kotlin/coil3/request · high confidence

Add shared data models for sample app images and screens

The sample app now includes shared Kotlin data classes defining the structure for image resources (including URI, dimensions, color, and Coil3 extras) and screen navigation states (listing and detail views with image and placeholder support).

shared · high confidence

Android test utilities now include dedicated test activities and bitmap comparison helpers

The internal test utilities for Android now provide a complete runtime environment for testing image loading, including \ComposeTestActivity\ and \ViewTestActivity\ declared in the AndroidManifest and implemented in Kotlin, along with the supporting layout and theme resources. Additionally, the \bitmaps.android.kt\ module introduces \getPixels()\ and \computeSimilarity()\ functions that allow tests to compare bitmap pixel data across ARGB channels, while \utils.android.kt\ adds robust helpers for decoding bitmaps from resources and assets with retry logic for emulator stability.

internal/test-utils/src/androidMain · high confidence

Android-specific image loading configuration and platform bindings

This update introduces Android-specific implementations and configuration options for the image loading library. It adds platform bindings for \ColorImage\, \BitmapImage\, and \DrawableImage\, along with conversion utilities between Android \Bitmap\/\Drawable\ and the library's \Image\ type. Developers can now configure the loader via \ImageLoader.Builder\ to control \bitmapFactoryMaxParallelism\, set an \ExifOrientationStrategy\ for \BitmapFactoryDecoder\, enable or disable the native \ImageDecoder\ (API 29+), and reduce the memory cache size while the app is in the background using \memoryCacheMaxSizePercentWhileInBackground\. The \RealImageLoader\ implementation also handles main-thread dispatching logic based on \ViewTarget\ or \ViewSizeResolver\ usage and registers Android-specific fetchers, decoders, and mappers.

coil-core/src/androidMain/kotlin/coil3 · high confidence

Coil 3 core library introduces new multiplatform image loading APIs

The coil-core module has been replaced with a new Coil 3 implementation, introducing a redesigned API surface for multiplatform image loading. Key additions include a new \ImageLoader\ interface with a builder pattern, a \ComponentRegistry\ for managing fetchers, decoders, mappers, and keyers, and a new \EventListener\ for tracking request progress. The library now features a custom \Uri\ class with builder support, a \ColorImage\ for drawing solid colors, and an \Extras\ system for request-specific data. Core interfaces like \Image\, \Target\, and \Transformation\ are stabilized, and the codebase is updated to use Kotlin 2.0.20 and kotlinx-coroutines 1.10.0.

coil-core/src/commonMain/kotlin/coil3 · high confidence

Initial public API dump for the coil-test library

The coil-test/api location now includes the initial ABI dump (coil-test.klib.api) for the coil-test library, exposing the public API surface for targets including iosArm64, iosSimulatorArm64, js, linuxArm64, linuxX64, macosArm64, and wasmJs. This dump documents the \FakeImage\ class and the \FakeImageLoaderEngine\ class (along with its \Builder\, \RequestValue\, and \ResultValue\ inner types), which serve as test utilities for simulating image loading and interception in Coil 3.

coil-test/api · high confidence

Introduce Coil Bill of Materials (BOM) module

A new \coil-bom\ module has been added to the project, providing a unified Bill of Materials for all public Coil artifacts. This allows consumers to import the BOM in their build configuration to manage dependency versions centrally, ensuring consistency across the library's modules without needing to specify individual versions for each artifact.

(dependencies) · high confidence

Introduce Ktor 2 network integration with concurrent request support

The Ktor 2 networking module has been split into its own artifact, providing a new \KtorNetworkFetcherFactory\ that allows users to configure network fetching with an \HttpClient\, \CacheStrategy\, \ConnectivityChecker\, and a new \ConcurrentRequestStrategy\. This strategy enables the library to await in-flight requests for the same resource, reducing redundant network traffic. The implementation includes platform-specific optimizations for JVM (using \RandomAccessFile\ for direct file channel writes) and non-JVM targets, and registers the fetcher via ServiceLoader for automatic discovery.

coil-network-ktor2/src · high confidence

Introduce OkHttp network fetcher for Coil 3

The coil-network-okhttp module now provides an OkHttp-based network fetcher for Coil 3, allowing users to fetch images using the OkHttp client. This includes a new \OkHttpNetworkFetcherFactory\ that supports lazy initialization of the \Call.Factory\, custom cache strategies, connectivity checking, and concurrent request strategies. The implementation wraps OkHttp responses into Coil's \NetworkClient\ and \NetworkResponseBody\ abstractions, and registers itself via ServiceLoader for automatic discovery. Android-specific tests verify integration with memory and disk caches, custom cache keys, and lazy initialization behavior.

coil-network-okhttp · high confidence

Introduce Skia-based image decoder for non-Android platforms

A new SkiaImageDecoder implementation has been added to the non-Android main source set, enabling image decoding via the Skia library. This decoder reads image bytes and utilizes Skia's Image and Bitmap classes to process and return decoded images, providing a consistent decoding path across non-Android targets.

coil-core/src/nonAndroidMain/kotlin/coil3/decode · high confidence

Introduce coil-network-cache-control module for HTTP cache support

A new \coil-network-cache-control\ module has been added, providing the \CacheControlCacheStrategy\ class to implement HTTP Cache-Control header support. This class implements the \CacheStrategy\ interface and exposes \read\ and \write\ methods for managing network responses and requests, available across JVM and multiplatform targets (iOS, Linux, macOS, JS, WASM).

coil-network-cache-control/api · high confidence

Lint warning for mistaken kotlin.error() usage in ImageRequest.Builder

The coil-lint module now includes a new detector that warns when Kotlin's standard library \error()\ function is used inside an \ImageRequest.Builder\ lambda (such as within \ImageView.load { }\). This common mistake, often caused by missing the \coil3.request.error\ import, causes the app to throw an \IllegalStateException\ at runtime instead of setting an error image. The new lint check helps developers catch this issue early by suggesting the correct Coil extension function.

coil-lint · high confidence

New Android View-based image targets

The library now provides a new set of Android-specific targets for displaying images in Views. A new \ViewTarget\ interface allows binding a \Target\ to a \View\, with automatic lifecycle observer registration. \GenericViewTarget\ offers a base implementation that simplifies updating \Drawable\s on a \View\ and automatically manages the start/stop state of animated drawables based on the lifecycle. \ImageViewTarget\ is a concrete implementation of \GenericViewTarget\ specifically for \ImageView\ components.

coil-core/src/androidMain/kotlin/coil3/target · high confidence

New Android fetchers for assets, content URIs, drawables, and resource URIs

The Android image loading library now includes dedicated fetcher implementations for four specific data sources: Asset URIs, Content URIs, Drawable objects, and Android Resource URIs. AssetUriFetcher handles images from the app's assets folder, while ContentUriFetcher adds specialized support for contact photos and music thumbnails (API 29+) alongside general content provider images. DrawableFetcher allows direct loading of Drawable instances, automatically converting vector drawables to bitmaps when necessary. ResourceUriFetcher enables loading images via android.resource:// URIs, supporting both XML-based drawables and raw resource streams. These components form the core fetching layer for these Android-specific data types in Coil 3.

coil-core/src/androidMain/kotlin/coil3/fetch · high confidence

New Android utility helpers for image requests, memory management, and bitmap handling

Coil now provides a set of Android-specific utility functions in the \coil3.util\ package to simplify common tasks and improve resource management. Developers can use \CoilUtils.dispose(view)\ and \CoilUtils.result(view)\ to conveniently cancel and retrieve results for image requests attached to Android Views. Memory management is enhanced with \SystemCallbacks\, which automatically trims the memory cache or reduces its maximum size when the app goes into the background or faces memory pressure. Additionally, \DrawableUtils\ offers a robust way to convert Drawables to Bitmaps with precise size and scaling control, while \contexts.kt\ provides helpers to calculate default memory cache sizes based on device RAM and resolve Android Lifecycles from Contexts.

coil-core/src/androidMain/kotlin/coil3/util · high confidence

New circle and rounded corners image transformations

Users can now crop images into a centered circle or apply rounded corners using the new CircleCropTransformation and RoundedCornersTransformation classes. These Android-specific transformations allow for flexible corner radius configuration (including individual radii per corner) and share a common internal painting implementation for efficient scaling and drawing.

coil-core/src/androidMain/kotlin/coil3/transform · high confidence

New coil-network-core public API surface for network abstraction

The coil-network-core module now exposes a stable public API defining the core network abstractions used by Coil. This includes the \NetworkClient\ interface for executing HTTP requests, \NetworkRequest\ and \NetworkResponse\ classes for carrying request data and response metadata (including \requestMillis\ and \responseMillis\), and \NetworkHeaders\/\NetworkRequestBody\/\NetworkResponseBody\ for handling HTTP content. The API also introduces \CacheStrategy\ for controlling caching behavior, \ConnectivityChecker\ for online/offline detection, and \ConcurrentRequestStrategy\ (with a \DeDupeConcurrentRequestStrategy\ implementation) to coordinate in-flight requests. Additionally, extension functions in \ImageRequestsKt\ allow setting HTTP method, headers, and body on image requests, and \NetworkFetcher\ provides the fetcher implementation that ties these components together.

coil-network-core/api · high confidence

New crossfade transition system for image loading

The Android image loading library now supports animated crossfade transitions when swapping images. This change introduces a new \Transition\ interface and \CrossfadeTransition\ implementation that animates the fade from the current drawable to a new one, configurable via duration and intrinsic size preferences. The system automatically skips animation for memory cache hits and error results, ensuring smooth user experiences without unnecessary processing.

coil-core/src/androidMain/kotlin/coil3/transition · high confidence

New decoding infrastructure and BlackholeDecoder for efficient preloading

The image decoding pipeline has been restructured with new core types: \Decoder\ and \DecodeResult\ now define the decoding contract, while \ImageSource\ provides a unified, thread-safe interface for accessing image data from files or buffered sources. A new \DataSource\ enum tracks where images originate (memory cache, memory, disk, or network). Additionally, a \BlackholeDecoder\ is introduced, allowing users to skip the actual image decoding step—useful for preloading images to disk without consuming memory for the decoded bitmap.

coil-core/src/commonMain/kotlin/coil3/decode · high confidence

New extensible network core with configurable caching and request coordination

The coil-network-core module introduces a new, extensible network layer that replaces the previous internal implementation. Users can now configure how network responses are cached via the new CacheStrategy interface, which controls read/write behavior to the disk cache. The system also supports de-duplicating concurrent requests for the same key through the ConcurrentRequestStrategy interface, reducing redundant network traffic. Additionally, a ConnectivityChecker interface allows applications to control whether network requests are executed based on device online status, and the NetworkFetcher now integrates these components to provide more granular control over network fetching, caching, and error handling.

coil-network-core/src/commonMain/kotlin/coil3/network · high confidence

New fetcher architecture supporting Bitmaps, ByteArrays, Data URIs, and File URIs

The image loading library now supports fetching images directly from Bitmap objects, byte arrays, data URIs, and file URIs via new internal fetchers (BitmapFetcher, ByteArrayFetcher, DataUriFetcher, FileUriFetcher). These fetchers utilize a new FetchResult sealed interface with SourceFetchResult and ImageFetchResult variants, allowing the system to handle in-memory data and encoded URIs without requiring external file storage. Users can now pass these data types directly to the image loader, which will automatically resolve them into images.

coil-core/src/commonMain/kotlin/coil3/fetch · high confidence

New iOS sample app for the Compose integration

The samples directory now includes a complete iOS application (CoilSample) that demonstrates the Kotlin Multiplatform Compose integration. This new sample provides the Xcode project structure, Swift UI wrappers, and asset configurations necessary to run the Compose app on iOS devices, alongside shared ProGuard rules for Android.

samples · high confidence

New interceptor chain for image loading requests

Coil 3 introduces a new interceptor system in the \coil3.intercept\ package, allowing developers to observe, transform, short-circuit, or retry image requests before they reach the engine. The \Interceptor\ interface and \RealInterceptorChain\ implementation provide a standard chain-of-responsibility pattern, while \EngineInterceptor\ serves as the final link that executes the actual fetch, decode, and transform logic. This change enables custom logic to modify request data, size, or result behavior without altering the core image loading engine.

coil-core/src/commonMain/kotlin/coil3/intercept · high confidence

New public API for video frame extraction and MediaDataSource support

The coil-video module now exposes a stable public API for video-specific operations. Users can extract video frames by index, time in microseconds/milliseconds, percentage, or specific options via new extension functions on ImageRequest and Options. Additionally, the module introduces VideoFrameDecoder for decoding frames and MediaDataSourceFetcher to support fetching video data from Android's MediaDataSource implementations.

coil-video/api · high confidence

New size resolution and scaling utilities for Android Views

This change introduces new internal components in the Android size module to improve how image dimensions are determined and rendered. It adds a \ViewSizeResolver\ interface and its \RealViewSizeResolver\ implementation, which asynchronously measure Android Views (handling padding and layout parameters) to provide accurate dimensions for image loading. Additionally, a \ScaleDrawable\ is added to center and scale child drawables to fill their bounds, ensuring that images with intrinsic dimensions smaller than their target view are properly scaled and centered rather than drawn at their original size.

coil-core/src/androidMain/kotlin/coil3/size · high confidence

New video frame extraction options and MediaDataSource support

The video module now supports extracting video frames by specific index (Android 28+), time in milliseconds/microseconds, or percentage of duration, giving users precise control over which frame is captured. It also introduces the ability to prefer embedded thumbnails from video files when available, which can improve performance and visual quality. Additionally, a new MediaDataSourceFetcher allows decoding video frames directly from MediaDataSource objects, expanding the types of data sources the library can handle.

coil-video/src/main/java/coil3/video · high confidence

Non-Android Compose image rendering and validation support

This change introduces the missing implementation layer for Coil's Compose integration on non-Android platforms (such as iOS, macOS, and desktop). It enables image drawing on Canvas by providing the \Image.asPainter\ conversion logic and a native canvas accessor, implements crossfade animation support via \AsyncImagePainter\ state handling, and adds request validation to ensure \target\ is null on these platforms. This allows developers to use the same Compose image APIs on non-Android targets as they do on Android.

coil-compose-core/src/nonAndroidMain · high confidence

Non-JVM platform implementations for Coil core components

This change introduces the non-JVM specific implementations for several core Coil components, enabling the library to function on platforms like Kotlin/JS and Kotlin/Native (non-JVM). It adds \RealImageLoader\ stubs that skip JVM-specific component registration, a thread-safe \ServiceLoaderComponentRegistry\ for managing fetchers and decoders, and utility functions for LRU maps, immutable collections, and file system free space (defaulting to 4GB). These additions complete the multiplatform support by providing the necessary platform-specific code paths for non-JVM targets.

coil-core/src/nonJvmCommonMain · high confidence

Public SVG parser interface and configurable SvgDecoder

The coil-svg module now exposes a public \Svg.Parser\ interface, allowing users to provide custom SVG parsing implementations via \SvgDecoder.Factory\. The \SvgDecoder\ and its factory have been updated to accept this parser, along with new configuration options for density handling (\density\, \scaleToDensity\) and intrinsic sizing (\useViewBoundsAsIntrinsicSize\). This change enables greater flexibility in how SVGs are decoded and rendered within the Coil image loading library.

coil-svg/api · high confidence

SVG rendering now supports deferred draw-time rendering and custom CSS injection

The SVG decoder now offers a \renderToBitmap\ option (enabled by default) that allows SVGs to be rendered at draw time instead of immediately as bitmaps, improving memory efficiency for complex images. Additionally, users can now inject custom CSS rules into SVGs via the \css\ extension on image requests, and the decoder exposes a public \Svg.Parser\ interface to enable custom SVG parsing implementations.

coil-svg/src · high confidence

Stabilize public Image APIs with SingletonImageLoader

The public API surface for image loading is now stabilized, introducing the \SingletonImageLoader\ class and its associated \Factory\ interface to manage global image loader instances. This change exposes Kotlin extension functions for Android (such as \load\ on \ImageView\ and \getImageLoader\ for \Context\) and JVM platforms, allowing users to easily load images into views and retrieve results using a centralized loader instance.

coil/api/android · high confidence

Stabilized Image API and added JVM-specific ImageLoaders utilities

The JVM API surface is now stabilized, introducing the \coil3.Image\ interface with a \draw\ method for Canvas rendering and concrete implementations like \BitmapImage\ and \ColorImage\. The \ImageLoader\ builder now exposes explicit \coroutineContext\ and \decoderCoroutineContext\ configuration options, and the \ImageLoaders\ companion object provides a new \executeBlocking\ utility for synchronous image loading on the JVM.

coil-core/api/jvm · high confidence

Support for fetching images from JAR files and direct ByteBuffers

Users can now load images directly from Java NIO ByteBuffers and from files packaged inside JAR archives on the JVM. A new ByteBufferFetcher allows passing in-memory byte data directly to the image loader, while a new JarFileFetcher enables loading images from resources located within JAR files using jar:file URIs.

coil-core/src/jvmCommonMain/kotlin/coil3/fetch · high confidence

Video library now supports service loader discovery

The video extension now registers its internal components via Java ServiceLoader, allowing the Coil framework to automatically discover and use the video frame decoder and media data source fetcher without explicit configuration. This change adds META-INF service provider files for coil3.video.internal.VideoFrameDecoderServiceLoaderTarget and coil3.video.internal.MediaDataSourceFetcherServiceLoaderTarget, enabling seamless integration of video capabilities into the core library.

coil-video/src/main/resources · high confidence

Removals

Removal of BuilderMarker DSL annotation

The \BuilderMarker\ annotation, previously used to restrict calling outer scopes in DSL builder classes, has been removed from the \coil.annotation\ package. This change eliminates the specific DSL scoping marker that was previously available for library consumers.

coil-base/src/main/java/coil/annotation · high confidence

Removal of CoilContentProvider

The CoilContentProvider class has been removed from the coil-default module. This eliminates the automatic initialization of the Coil singleton via an Android ContentProvider, requiring users to ensure Coil is initialized through other means if they were relying on this mechanism.

coil-default/src/main/java/coil/util · high confidence

Removal of CrossfadeDrawable implementation

The \CrossfadeDrawable\ class, which previously handled crossfading transitions between two drawables, has been removed from the \coil-base\ module. This change eliminates the built-in crossfade capability provided by this specific drawable implementation.

coil-base/src/main/java/coil/drawable · high confidence

Removal of GlobalLifecycle and LifecycleCoroutineDispatcher

The internal \GlobalLifecycle\ fallback implementation and the \LifecycleCoroutineDispatcher\ have been removed from the lifecycle module. This eliminates the previous mechanism that queued coroutine work while a lifecycle was not started and provided a permanent 'resumed' lifecycle fallback, simplifying the internal lifecycle handling.

coil-base/src/main/java/coil/lifecycle · high confidence

Removal of ImageLoader extension functions

The \ImageLoaders.kt\ file containing extension functions for \ImageLoader\ (such as \load\ and \get\ for various data types like String, Uri, File, and Drawable) has been removed. Users can no longer call these convenience methods directly on \ImageLoader\ instances and must instead use the explicit builder classes (\LoadRequestBuilder\ and \GetRequestBuilder\) to construct requests.

coil-base/src/main/java/coil/api · high confidence

Removal of MovieDrawable GIF rendering implementation

The MovieDrawable class, which was responsible for rendering animated GIFs using Android's legacy Movie API, has been removed from the coil-gif module. This eliminates the software-based canvas rendering path and associated scaling logic for GIFs, aligning with the library's preference for using ImageDecoderDecoder and AnimatedImageDrawable on Android P and above.

coil-gif/src/main/java/coil/drawable · high confidence

Removal of built-in image transformations

The built-in image transformation classes—BlurTransformation, CircleCropTransformation, GrayscaleTransformation, and RoundedCornersTransformation—have been removed from the coil-base module. Users can no longer apply these effects directly via the transformation API; these capabilities must now be implemented externally or handled through other means such as Jetpack Compose clipping.

coil-base/src/main/java/coil/transform · high confidence

Removal of internal BitmapPool implementation

The internal BitmapPool interface and its RealBitmapPool implementation have been removed from the coil-base module. This change eliminates the local bitmap object pooling logic, which previously managed bitmap reuse and memory limits via an LRU eviction policy, from this specific code location.

coil-base/src/main/java/coil/bitmappool · high confidence

Removal of internal collection utilities

The internal collection utilities in the coil-base module have been removed. Specifically, the \ArrayUtils\ object, the \GroupedLinkedMap\ class, and the \SparseIntArraySet\ class along with its extension functions in \SparseIntArraySets\ have been deleted from the codebase. This change eliminates these specific data structure implementations from the library's internal storage layer.

coil-base/src/main/java/coil/collection · high confidence

Removal of internal network connectivity monitoring classes

The internal classes responsible for monitoring device network state—specifically \NetworkObserver\, \NetworkObserverStrategy\, and \HttpException\—have been removed from the \coil.network\ package. This eliminates the library's built-in mechanism for detecting online/offline connectivity changes and the associated exception type, meaning any logic previously handled by these internal observers is no longer present in this module.

coil-base/src/main/java/coil/network · high confidence

Removal of internal utility and logging infrastructure

The internal utility layer in coil-base has been removed, deleting files that previously handled logging (CoilLogger, Logs), context helpers (Contexts), bitmap and memory calculations (Utils, Extensions), and coroutine callbacks (ContinuationCallback). This eliminates the internal logging mechanism and several helper functions used for memory/cache sizing and context resolution within this module.

coil-base/src/main/java/coil/util · high confidence

Removal of legacy Coil and ImageView extension functions

The legacy extension functions for loading images via the \Coil\ singleton and \ImageView\ instances have been removed from the \coil.api\ package. This deletion eliminates the convenience methods that previously allowed direct calls like \Coil.load()\ or \imageView.load()\, requiring users to migrate to the newer \ImageLoader\ API for image loading operations.

coil-default/src/main/java/coil/api · high confidence

Removal of legacy GIF and animated WebP decoders

The \GifDecoder\ (which used the deprecated \android.graphics.Movie\ API) and \ImageDecoderDecoder\ (which used the Android P+ \ImageDecoder\ API) have been removed from the \coil-gif\ module. This eliminates the manual decoding logic for GIF and animated WebP images, implying that support for these formats is now handled by a different component or module within the library.

coil-gif/src/main/java/coil/decode · high confidence

Removal of legacy Target and ViewTarget interfaces

The legacy \Target\, \ViewTarget\, and \PoolableViewTarget\ interfaces, along with the \ImageViewTarget\ implementation, have been removed from the \coil.target\ package. This change eliminates the previous mechanism for handling image load results and bitmap pooling via these specific interfaces, requiring users to adopt the updated request and target APIs.

coil-base/src/main/java/coil/target · high confidence

Removal of legacy data mapping interfaces and implementations

The \coil.map\ package has been removed, eliminating the legacy \Mapper\ and \MeasuredMapper\ interfaces along with their built-in implementations (\FileMapper\, \HttpUriMapper\, \StringMapper\). This change removes the previous mechanism for converting raw data types (such as \File\, \String\, or \Uri\) into fetcher-compatible types, indicating a shift in how the library handles data ingestion and source resolution.

coil-base/src/main/java/coil/map · high confidence

Removal of legacy decode infrastructure classes

The \BitmapFactoryDecoder\, \DataSource\, \DecodeResult\, \DecodeUtils\, \Decoder\, \DrawableDecoderService\, \EmptyDecoder\, and \Options\ classes have been removed from the \coil.decode\ package. This cleanup eliminates legacy decoding logic and utility classes that are no longer part of the active image pipeline, simplifying the library's internal architecture.

coil-base/src/main/java/coil/decode · high confidence

Removal of legacy fetcher and result classes

The \coil.fetch\ package has removed several internal classes: \BitmapFetcher\, \DrawableFetcher\, \ResourceFetcher\, \UriFetcher\, and \HttpUrlFetcher\, along with the \Fetcher\ interface and \FetchResult\ sealed class hierarchy (\SourceResult\, \DrawableResult\). This cleanup eliminates the previous mechanism where fetchers translated data into either a \BufferedSource\ or a \Drawable\ directly, simplifying the internal fetching architecture.

coil-base/src/main/java/coil/fetch · high confidence

Removal of legacy size resolution classes and enums

The \DisplaySizeResolver\, \Scale\, \Size\, \SizeResolver\, and \ViewSizeResolver\ classes in the \coil.size\ package have been removed. This eliminates the previous API for defining image target sizes and resolving view dimensions, indicating a shift in how image sizing is handled within the library.

coil-base/src/main/java/coil/size · high confidence

Removed redundant configuration files from the sample app

The coil-sample module no longer includes the .gitignore file (which previously excluded the /build directory) and the shrinker-rules.pro file (which contained ProGuard configuration rules). These files have been deleted as they are considered redundant for the sample project.

coil-sample · high confidence

API

Introduce coil-gif API surface for animated image support

The coil-gif module now exposes its public API, defining the core classes and functions required to handle animated GIFs. This includes the \AnimatedImageDecoder\ and \GifDecoder\ for decoding, \MovieDrawable\ for rendering with animation callbacks, and \AnimatedTransformation\ for applying effects. The API also provides builder extensions in \ImageRequestsKt\ to configure repeat counts and animation start/end callbacks on requests, alongside utility functions in \DecodeUtilsKt\ to detect animated formats like HEIF and WebP.

coil-gif/api · high confidence

Public API surface for SVG decoding on JVM and Android

This change introduces the public API definitions for SVG support in the JVM and Android modules of coil-svg. On Android, the API exposes \SvgDecoder\ and \SvgDecoder.Factory\ which accept a \Svg.Parser\ for custom parsing, along with options for density scaling (\scaleToDensity\), bitmap rendering (\renderToBitmap\), and CSS configuration. On the JVM, the API provides equivalent \SvgDecoder\ and \SvgDecoder.Factory\ classes using the JetBrains Skia SVG backend instead of Android's native SVG library. Both platforms expose the core \Svg\ interface, \Svg.ViewBox\ data class, and utility functions like \isSvg\ and \getCss\, enabling developers to integrate SVG decoding into image loading pipelines with consistent configuration options across platforms.

coil-svg/api/jvm · high confidence

Stabilized Coil 3 Android API surface

The Android-specific public API for Coil 3 has been stabilized and published, defining the official contract for developers. This release introduces the core \Image\ interface and its implementations (\BitmapImage\, \ColorImage\, \DrawableImage\), alongside the \ComponentRegistry\ for managing decoders, fetchers, and interceptors. The \ImageLoader\ builder now exposes explicit configuration for coroutine contexts (including separate contexts for decoding and fetching) and disk caching policies. Additionally, the new \Extras\ system allows passing arbitrary typed data through requests, and the \EventListener\ API provides detailed lifecycle hooks for monitoring image loading stages.

coil-core/api/android · high confidence

Updated public API surface for coil-core

The public API dump for coil-core has been updated to reflect recent changes, including the addition of \cleanupCoroutineContext\ to \DiskCache.Builder\, the introduction of \DataSource\ and \CachePolicy\ enums, and the definition of core interfaces like \Mapper\, \Keyer\, \Decoder\, \Fetcher\, and \Interceptor\. This change ensures the binary compatibility validation reflects the current state of the library's public contract for targets including iOS, Linux, macOS, JS, and wasmJs.

coil-core/api · high confidence

Behavioural changes

1 commit (0 fixes) modifying (repo-wide), buildSrc, karma.config.d

A change to existing behaviour in (repo-wide), buildSrc, karma.config.d — 1 commit, 3 files: “Enforce JS/WASM test max parallism in Gradle (\#3658)” (refs \#3658). Also in this area: Stabilize browser tests by disabling WASM streaming and increasing timeouts.

karma.config.d · low confidence · unverified

1 commit (0 fixes) modifying coil-network-core, coil-network-httpengine, samples/shared

A change to existing behaviour in coil-network-core, coil-network-httpengine, samples/shared — 1 commit, 19 files: “Add coil-network-httpengine module (\#3659)” (refs \#3659).

coil-network-httpengine · medium confidence · unverified

2 commits (0 fixes) modifying coil-core/src/jsCommonMain/kotlin/coil3/fetch

A change to existing behaviour in coil-core/src/jsCommonMain/kotlin/coil3/fetch — 2 commits, 2 files: “Adds support for loading images from blob URLs (object URLs) on web (JS/Wasm) targets (\#3504)”; “Preserve MIME types for JavaScript blob fetches (\#3537)” (refs \#3504, \#3537).

coil-core/src/jsCommonMain/kotlin/coil3/fetch · medium confidence · unverified

2 commits (1 fix) modifying internal/test-compose-screenshot

A change to existing behaviour in internal/test-compose-screenshot — 2 commits (1 fix), 5 files: “Migrate screenshot tests to Android test suite support (\#3590)”; “Fix fetching vector drawables in the Android Studio preview. (\#2713)” (refs \#3590, \#2713).

internal/test-compose-screenshot · medium confidence · unverified

5 commits (1 fix) modifying coil-core/src/wasmJsMain

A change to existing behaviour in coil-core/src/wasmJsMain — 5 commits (1 fix), 6 files: “Implement the WeakReference memory cache in common code. (\#2243)”; “Adds support for loading images from blob URLs (object URLs) on web (JS/Wasm) targets (\#3504)”; “Fix missing ExperimentalWasmJsInterop opt in. (\#3171)”; and 2 more (refs \#2243, \#3504, \#3171, \#2399, \#3537).

coil-core/src/wasmJsMain · medium confidence · unverified

Add non-Android platform implementations for core utility functions

This change introduces the missing platform-specific implementations for several utility functions in the \coil3.util\ package, enabling the library to function correctly on non-Android targets. Specifically, it provides no-op handlers for system callbacks (memory pressure and shutdown), defines the default memory cache size percentage (15%) and application context resolution, disables asset URI support, and implements bitmap creation and image preparation logic using Skia. These additions ensure that core image loading and caching behaviors are properly defined for non-Android environments rather than failing or relying on incomplete stubs.

coil-core/src/nonAndroidMain/kotlin/coil3/util · high confidence

Adds JVM-specific implementations for Coil core utilities

This change introduces platform-specific Kotlin files for the non-JS target (primarily JVM) to resolve missing implementations. It adds a blocking \executeBlocking\ extension function on \ImageLoader\ that runs image requests synchronously, provides the default \FileSystem\ and \IO\ coroutine dispatcher implementations, and defines a singleton \DiskCache\ instance used by default in \ImageLoader.Builder\. These additions ensure that core image loading and caching behaviors function correctly on JVM environments where these platform-specific details were previously absent.

coil-core/src/nonJsCommonMain · high confidence

Adjust test timeouts and add Chrome launcher for flakiness mitigation

The test configuration has been updated to reduce flakiness by increasing browser activity, disconnect, and capture timeouts to 400 seconds, setting the Mocha test timeout to 60 seconds, and delaying the process exit by 5 seconds to ensure logs are fully captured. Additionally, a custom Chrome launcher for compose tests has been added with specific flags to enable WebGL and bypass sandbox restrictions.

coil-core/karma.config.d · high confidence

Android image conversion logic for transformations implemented

The Android-specific implementation for converting images to bitmaps before applying transformations has been added. This change ensures that images are properly converted to a compatible bitmap format (handling existing BitmapImage instances and other drawable types) to support the application of transformations on Android targets.

coil-core/src/androidMain/kotlin/coil3/intercept · high confidence

Android request lifecycle management and view target handling

This change introduces Android-specific request delegates and managers to handle image loading lifecycle. It adds \LifecycleRequestDelegate\ for one-shot requests and \ViewTargetRequestDelegate\ for restartable view-based requests, ensuring requests are automatically cancelled when views are detached and restarted when attached. The \ViewTargetRequestManager\ is attached to views to coordinate these lifecycle events and manage concurrent requests. Additionally, it implements logic to resolve size, scale, and precision based on \ImageView\ properties (like \ScaleType\) and sets memory cache extras for transformations.

coil-core/src/androidMain/kotlin/coil3/request · high confidence

Android resource URI handling and disk cache directory configuration

Coil 3 now correctly handles Android resource URIs by incorporating the device's night mode state into the cache key, ensuring that cached images update when the theme changes. It also introduces mappers to convert Android-specific resource identifiers and URIs into Coil's internal URI format, and provides a builder extension to configure the disk cache directory on JVM platforms.

coil-core/src/androidMain/kotlin/coil3/key, coil-core/src/androidMain/kotlin/coil3/map, coil-core/src/jvmCommonMain/kotlin/coil3/disk · high confidence

Android sample app manifest and shared resource linkage

The Android sample app now includes an explicit AndroidManifest.xml that declares network permissions, sets the main activity as the launcher entry point, and enables the back-invoked callback for improved navigation handling. Additionally, the app's assets directory is linked to the shared common resources, allowing the sample to access shared assets directly.

samples/view/src/main · high confidence

Android-specific image rendering and request validation in Compose

This change introduces Android-specific implementations for the Compose image pipeline. It adds \AsyncImagePainter\ logic to handle crossfade transitions between image states and implements \Image.asPainter\ to correctly render \BitmapImage\ and \DrawableImage\ types using Compose-compatible painters. Additionally, it defines \LocalPlatformContext\ to provide the Android \Context\ to the Compose hierarchy and enforces validation that prevents setting \target\ or \lifecycle\ properties on image requests within the Compose layer.

coil-compose-core/src/androidMain/kotlin · high confidence

Apple-specific image loading and memory estimation improvements

On Apple platforms, the image loader now includes an NSURLMapper to handle NSURL data sources, and the available memory estimation for cache sizing is based on physical memory (25% of total, capped at 1 GB) instead of previous heuristics.

coil-core/src/appleMain · high confidence

AsyncImage API overhaul with crossfade support and new size resolvers

The Coil Compose API has been significantly restructured to support smoother image transitions and more flexible layout sizing. Users can now enable crossfade animations between subsequent image results using the new CrossfadePainter, which is exposed as public API with configurable properties like duration and content scale. The AsyncImage and SubcomposeAsyncImage composables have been updated with new overloads and parameters, including support for disabling clipToBounds and a new AsyncImageModelEqualityDelegate to control when image requests are re-triggered. Additionally, new public APIs like ConstraintsSizeResolver and DrawScopeSizeResolver, along with their remember functions, provide finer control over image sizing within Compose layouts, while LocalAsyncImagePreviewHandler and LocalAsyncImageModelEqualityDelegate composition locals allow for global configuration of preview and equality behaviors.

coil-compose-core/api/android · high confidence

AsyncImage API overhaul with new state model and crossfade support

The \AsyncImage\ and \SubcomposeAsyncImage\ composables have been updated to expose a new \AsyncImagePainter\ with a structured \State\ model (Empty, Loading, Success, Error) and a \restart()\ method, allowing for more granular control over image loading lifecycle. The API now includes built-in crossfade transitions between subsequent image results, configurable via \CrossfadePainter\, and introduces \AsyncImageModelEqualityDelegate\ to control when requests are re-triggered. Additionally, \clipToBounds\ is now configurable on \SubcomposeAsyncImage\, and preview handling is managed via the new \LocalAsyncImagePreviewHandler\ composition local.

coil-compose-core/api/jvm · high confidence

AsyncImage rendering and performance improvements

AsyncImage now uses a custom Modifier.Node-based implementation (ContentPainterModifier) to handle painting, which improves performance and fixes crashes when measuring images with inverted constraints or when the parent uses IntrinsicSize. The component no longer automatically waits for draw size before rendering, allowing images to appear sooner. Additionally, ImageRequests are now correctly recreated when ContentScale changes to or from None, and the internal coroutine dispatching logic has been simplified to remove reliance on Dispatchers.Main.immediate.

coil-compose-core/src/commonMain/kotlin/coil3/compose/internal · high confidence

Bitmap pool strategy selection logic removed

The internal logic for selecting a bitmap pooling strategy based on Android SDK version has been removed. The \BitmapPoolStrategy\ interface, along with its implementations (\AttributeStrategy\, \SizeConfigStrategy\, and \SizeStrategy\) and the factory logic that chose between them, has been deleted from the codebase.

coil-base/src/main/java/coil/bitmappool/strategy · high confidence

Coil 3.6.3 release and repository documentation overhaul

This release (3.6.3) fixes build failures with Android Gradle Plugin 9.4.0 and R8 caused by invalid characters in Kotlin module name metadata. The repository documentation has been significantly updated: the main README now targets Compose Multiplatform and lists translations in nine languages (Japanese, Korean, Russian, Swedish, Turkish, Chinese, Persian, Uzbek), while new files (AGENTS.md, CLAUDE.md, GEMINI.md) provide AI assistant guidelines. The release process is now documented in RELEASING.md, and the deploy\_docs.sh script has been refactored to use a new assemble\_docs.sh helper, explicitly copy translated READMEs, and build the Compose WASM sample.

(repo-wide) · high confidence

Consolidation of LoadRequest and GetRequest into ImageRequest

The distinct LoadRequest and GetRequest classes, along with their corresponding builders and the RequestDisposable interface, have been removed from the coil.request package. This change merges the previous load and get request types into a unified ImageRequest, simplifying the API by eliminating the need to choose between separate request types for loading images into views versus retrieving raw image data.

coil-base/src/main/java/coil/request · high confidence

Disable disk caching and file system access on JavaScript targets

On JavaScript platforms, Coil now defaults to an empty disk cache and provides a file system implementation that throws an exception for any read or write operation. This ensures that image loading does not attempt to access the local file system, which is unsupported in standard browser environments, and prevents runtime errors when disk-based caching is requested.

coil-core/src/jsCommonMain/kotlin/coil3/util · high confidence

Enable GIF decoding via Java ServiceLoader

The coil-gif module now registers its decoder implementation through the standard Java ServiceLoader mechanism. By adding a service provider configuration file, the GIF decoder is automatically discovered and available without requiring explicit manual registration, simplifying integration for users relying on service-based discovery.

coil-gif/src/main/resources · high confidence

Image transformation support on non-Android platforms

The non-Android implementation of the image engine now includes a concrete \convertImageToBitmap\ function. When an image requires transformation, this function attempts to convert it to a bitmap; if the image is already a bitmap, it returns it directly. If the image type cannot be converted on non-Android platforms, the system throws an error and advises users to disable bitmap conversion in the request builder to skip transformations.

coil-core/src/nonAndroidMain/kotlin/coil3/intercept · high confidence

Improved GIF playback performance on older Android versions

Animated GIFs now play more smoothly on devices running Android 33 and below by enforcing a minimum frame delay. The library introduces a new internal mechanism that rewrites GIF frame delays below a 20ms threshold to 100ms during decoding, preventing excessively fast playback. This behavior is applied automatically via the GifDecoder on older Android versions (API \< 28), while the native AnimatedImageDecoder on Android 28+ continues to handle frame timing natively.

coil-gif/src/main/java/coil3/gif/internal · high confidence

Improved video frame extraction and internal resource handling

This change enhances the video decoding internals by adding support for extracting video frames by index, which allows for more precise frame retrieval. It also introduces a new FileHandleMediaDataSource to better support custom FileSystem implementations and registers service loader targets for MediaDataSourceFetcher and VideoFrameDecoder to improve extensibility. Additionally, utility functions are added to handle MediaMetadataRetriever lifecycle and API differences across Android versions, ensuring compatibility and avoiding strict mode warnings.

coil-video/src/main/java/coil3/video/internal · high confidence

Initial public API dump for Coil 3

A new ABI dump file (coil.klib.api) has been added to the repository, establishing the public API surface for the coil3 library. This file documents the stable interface for the SingletonImageLoader, including its methods for retrieving, resetting, and configuring image loaders, as well as the Factory interface used to instantiate them. This change supports the new klib validation feature by providing a baseline for binary compatibility checks.

coil/api · high confidence

Introduce adaptive image grid and edge-to-edge layout in the View sample

The View-based sample app now features an adaptive image grid that dynamically adjusts its column count based on available screen width, replacing the previous static layout. Additionally, the app has been updated to support edge-to-edge rendering, ensuring content extends behind system bars for a more immersive display. These changes are implemented through new custom views (AspectRatioImageView, ImageGridView) and updated activity logic handling window insets.

samples/view/src/main/java · high confidence

Introduction of Coil API visibility and stability annotations

The Coil library now provides a set of annotations to clarify API stability and usage constraints. \ExperimentalCoilApi\ marks incubating features with binary compatibility warnings, while \InternalCoilApi\ hides implementation details that may change without migration aids. \DelicateCoilApi\ flags APIs that require careful usage, typically for testing. Additionally, \VisibleForTesting\, \MainThread\, and \WorkerThread\ annotations help enforce visibility and threading constraints, and the internal \Poko\ annotation enables data-class-like behavior for specific classes.

coil-core/src/commonMain/kotlin/coil3/annotation · high confidence

JVM memory cache sizing and ProGuard rules for non-Android platforms

The JVM implementation of Coil now correctly sizes the memory cache by querying \Runtime.getRuntime().maxMemory()\, falling back to 8 GB if the value is unavailable, which prevents incorrect cache limits on JVM targets. Additionally, ProGuard rules are bundled with the non-Android JVM artifact to preserve \volatile\ fields required by AtomicFu and to keep ServiceLoader targets intact, ensuring correct behavior when code is obfuscated or shrunk.

coil-core/src/jvmMain · high confidence

Lazy, background-thread service loading for Coil components

The Coil library now defers the loading of service-provided fetchers and decoders until they are first accessed on a background thread. This change, implemented in the new \ServiceLoaderComponentRegistry\ and supporting utility files, ensures that the potentially expensive \ServiceLoader\ initialization does not block the main thread, improving startup responsiveness for applications using this version of the library.

coil-core/src/jvmCommonMain/kotlin/coil3/util · high confidence

Memory cache now evicts unshareable images and supports weak references

The memory cache implementation has been refactored to use a dual-layer strategy with strong and weak reference caches. When retrieving an image, unshareable images are now immediately removed from the cache to prevent memory leaks. Additionally, the cache builder allows enabling or disabling weak reference tracking, which helps retain images in memory without contributing to the cache size limit, improving availability of recently used images that haven't been garbage collected yet.

coil-core/src/commonMain/kotlin/coil3/memory · high confidence

Migrate compose-android sample to new Android KMP Gradle plugin

The compose-android sample has been migrated to use the new Android KMP Gradle plugin. This update includes a structural change where the assets directory now symlinks to the shared common resources, allowing the Android app to access shared assets directly. The main entry point has been updated to a new MainActivity that utilizes the Android-specific ViewModel and enables edge-to-edge display. Additionally, the AndroidManifest.xml has been refactored to remove legacy external storage permissions, update the application package context, enable the back-invoked callback for improved navigation handling, and add profileable attributes for better debugging support.

samples/compose-android · high confidence

New Android image decoding infrastructure with configurable EXIF handling

This change introduces the core Android decoding components for Coil 3, including \BitmapFactoryDecoder\ and \StaticImageDecoder\ (for API 29+), along with supporting utilities. A key behavioral addition is the new \ExifOrientationStrategy\ interface, which allows users to control how EXIF orientation data is handled via three built-in modes: \IGNORE\, \RESPECT\_PERFORMANCE\ (the default, respecting orientation for JPEG, WebP, HEIC, and HEIF), and \RESPECT\_ALL\. The decoders also implement parallelism locking to coordinate with other decoders and support modern Android bitmap options such as hardware allocation, specific color spaces, and partial image handling.

coil-core/src/androidMain/kotlin/coil3/decode · high confidence

New Gradle build infrastructure for Coil 3

The build system has been completely rewritten for Coil 3, introducing a new Kotlin-based build source structure under \buildSrc/src/main/kotlin/coil3\. This update adds a custom Kotlin Multiplatform hierarchy template to standardize source set grouping (e.g., \jvmCommon\, \native\, \jsCommon\), integrates native Linux targets by default, and enables Kotlin/Wasm (wasmJs) support out of the box. It also includes new Gradle tasks to automatically link Skiko builtins for Android, verify that Skiko versions match between core and Compose modules, and manage Skiko runtime dependencies for WebAssembly without requiring the full Compose plugin. Additionally, the build now configures Android libraries using the new Kotlin Multiplatform Android plugin and updates publishing and Dokka settings to align with Coil 3's module structure.

buildSrc/src/main/kotlin/coil3 · high confidence

New animated image decoding and control APIs for GIFs and WebPs

The coil-gif module now includes dedicated decoders for modern animated formats: AnimatedImageDecoder handles GIFs, animated WebPs, and animated HEIFs on Android API 28+ using the native ImageDecoder, while GifDecoder remains for legacy API support. Users can now globally or per-request set the animation repeat count (including a new ENCODED\_LOOP\_COUNT option to respect the file's metadata) and register start/end animation callbacks. Additionally, an experimental AnimatedTransformation interface allows applying pixel-level transformations to animated frames, with the system automatically handling scaling and opacity calculations.

coil-gif/src/main/java/coil3/gif · high confidence

New disk cache implementation with configurable cleanup context

The disk cache module has been replaced with a new implementation that introduces a \cleanupCoroutineContext\ configuration option, allowing users to specify the coroutine context for background cache size trim operations. The previous \cleanupDispatcher\ method is now deprecated in favor of this more flexible context-based approach. The new cache also includes improved fault handling via a \FaultHidingSink\ to prevent I/O errors from crashing writes, and ensures data integrity by adding missing flush calls to the underlying \DiskLruCache\.

coil-core/src/commonMain/kotlin/coil3/disk · high confidence

New internal utility and platform-abstraction layer in coil3.util

This change introduces a new set of internal utility files in the coil3.util package to support the core image-loading logic. It adds an LRU cache implementation (LruCache.kt), a service loader-based component registry (ServiceLoaderComponentRegistry.kt), and platform-specific expect declarations for system callbacks, file systems, coroutine dispatchers, and application context (SystemCallbacks.kt, fileSystems.kt, contexts.kt, coroutines.kt). It also provides internal helper functions for collections, logging (Logger and DebugLogger), MIME type detection (MimeTypeMap), and general utilities (utils.kt), establishing the foundational infrastructure for caching, platform interoperability, and resource management.

coil-core/src/commonMain/kotlin/coil3/util · high confidence

New public API for crossfade transitions and model equality in AsyncImage

The coil-compose-core library now exposes \CrossfadePainter\ as a public API, enabling smooth visual transitions between subsequent image results in \AsyncImage\. This change also introduces \AsyncImageModelEqualityDelegate\ (with an \AllProperties\ implementation) and a \LocalAsyncImageModelEqualityDelegate\ composition local, allowing users to customize how image model changes are detected to trigger these crossfade effects. Additionally, \AsyncImagePainter\ now exposes a \restart()\ method for manual control over the loading lifecycle.

coil-compose-core/api · high confidence

New size resolution API with precise dimension and scaling control

The size resolution system has been redesigned to offer finer control over image dimensions and scaling. Users can now define target sizes using a new \Dimension\ type that supports both fixed pixel values and an \Undefined\ state (for unbounded dimensions like WRAP\_CONTENT), allowing images to be loaded at their original size when no specific dimensions are required. A new \Precision\ enum lets users choose between \EXACT\ matching or \INEXACT\ matching, where the latter enables memory optimizations by reusing cached images or loading originals if they are smaller than requested. Additionally, the \Scale\ enum now explicitly defines \FIT\ and \FILL\ behaviors, determining how the source image is scaled to fit the resolved target size.

coil-core/src/commonMain/kotlin/coil3/size · high confidence

Refactored image request lifecycle and configuration into new core request classes

The image request execution model has been restructured to improve resource management and configuration clarity. A new \Disposable\ interface and \OneShotDisposable\ implementation now explicitly represent the lifecycle of an executed request, allowing users to cancel work and release resources via \dispose()\. The \ImageRequest\ class has been redesigned as an immutable value object with a dedicated \Defined\ inner class to track explicitly set builder values, ensuring that defaults are applied only when necessary. Additionally, a new \Options\ class centralizes fetch and decode configuration (such as size, scale, precision, and cache policies), decoupling these settings from the request builder. The \CachePolicy\ enum has been moved to the core module and updated to reference \ImageRequest\ properties, and new extension functions in \imageRequests.kt\ provide standardized ways to configure transformations, crossfades, and bitmap size limits.

coil-core/src/commonMain/kotlin/coil3/request · high confidence

Refactored singleton image loader to use PlatformContext for factory resolution

The singleton image loader implementation has been updated to resolve the application context via a new \PlatformContext.applicationContext()\ extension function rather than relying on platform-specific direct access. This change centralizes context retrieval within the \PlatformContext\ abstraction, ensuring that the singleton factory logic consistently uses the correct application-level context across different platforms. The public API surface remains largely unchanged, but the internal mechanism for obtaining the context during lazy initialization has been standardized.

coil/src/commonMain · high confidence

Removal of Coil singleton object

The \Coil\ singleton object, which previously provided static methods to get or set the default \ImageLoader\ instance, has been removed from the library. Users can no longer access the default loader via \Coil.loader()\ or configure it using \Coil.setDefaultImageLoader()\. This change eliminates the global singleton pattern for the default image loader, requiring users to manage \ImageLoader\ instances explicitly or through alternative initialization mechanisms.

coil-default/src/main/java/coil · high confidence

Removal of internal memory management and request delegation classes

The internal memory management and request delegation infrastructure in the \coil.memory\ package has been removed. This includes the deletion of \BitmapReferenceCounter\, \DelegateService\, \MemoryCache\, \RequestDelegate\, \RequestService\, \TargetDelegate\, and \ViewTargetRequestManager\. These classes previously handled bitmap reference counting, memory caching, request lifecycle management, and target delegation; their removal indicates a significant internal refactoring of how the library manages memory and request lifecycles.

coil-base/src/main/java/coil/memory · high confidence

Removal of legacy buildSrc utility files

The \Extensions.kt\ and \Library.kt\ files in \buildSrc/src/main/kotlin\ have been removed. This eliminates custom Gradle extension functions (such as \minSdk\, \versionCode\, and test dependency helpers) and the centralized \Library\ object that previously managed hardcoded versions for AndroidX, Coroutines, OkHttp, and other dependencies, indicating a shift to a different dependency management strategy (likely version catalogs or external build scripts).

buildSrc/src/main/kotlin · high confidence

Removal of legacy image loading components and configuration classes

The \ComponentRegistry\, \DefaultRequestOptions\, \ImageLoader\, \ImageLoaderBuilder\, and \RealImageLoader\ classes have been removed from the \coil\ package. This change eliminates the previous builder-based configuration model and the internal implementation of the image loader, indicating a significant restructuring of how image loading is initialized and configured in this library version.

coil-base/src/main/java/coil · high confidence

Replace ImageLoader network observer with ConnectivityChecker interface

The network connectivity check mechanism has been refactored to use a new \ConnectivityChecker\ interface instead of the previous \ImageLoader.Builder.networkObserverEnabled\ setting. On Android, this introduces platform-specific logic that leverages \ConnectivityManager\ to determine online status, handling API level differences (API 21 vs 23) and checking for the \ACCESS\_NETWORK\_STATE\ permission. Non-Android platforms now default to an always-online state via this interface. This change also includes internal utilities to assert non-main-thread execution and check permissions, ensuring the connectivity check is performed safely and correctly on the respective platforms.

coil-network-core/src/androidMain · high confidence

Restrict which HTTP response codes are cacheable

The default caching strategy now strictly limits which HTTP status codes are written to disk. Previously, all 2xx responses were cached; the new implementation retains this behavior but also explicitly allows specific non-2xx codes (300, 301, 404, 405, 410, 414, 501) that are cacheable by RFC semantics, while disabling disk writes for all other non-cacheable status codes.

coil-network-core/src/commonMain/kotlin/coil3/network/internal · high confidence

Sample app architecture migrated to modern Android components

The coil-sample application has been refactored to replace legacy Android patterns with modern equivalents. The custom \Application\ class and manual \ImageLoader\ setup have been removed, indicating a shift to automatic initialization or a different provider pattern. ViewModels and Activities no longer use \LiveData\ and \ViewModelProviders\, having migrated to \StateFlow\ and ViewBinding. Additionally, custom utility extensions for inflation, view binding, and TLS 1.2 enforcement have been deleted, suggesting these functionalities are now handled by standard library components (like \activity-ktx\ and \livedata-ktx\) or Coil's built-in configuration.

coil-sample/src/main/java · high confidence

Shared sample infrastructure migrated to Material 3 and Coil 3

The shared sample codebase has been restructured to support cross-platform consistency and modern UI standards. The Android sample now uses Material 3 (Theme.Material3.DayNight.NoActionBar) and enables edge-to-edge display for a seamless look. Image loading has been upgraded to Coil 3, with platform-specific implementations for disk caching (disabled on JS/Wasm, enabled on Android/other) and video frame extraction. Asset management is now centralized via a common \Resources\ interface and \AssetType\ enum, with JSON manifests for JPGs, GIFs, and SVGs moved to common resources, while MP4 support is restricted to Android.

samples/shared · high confidence

Split Ktor network support into separate Ktor 2 and Ktor 3 artifacts

The single \coil-network-ktor\ module has been split into two distinct artifacts, \coil-network-ktor2\ and \coil-network-ktor3\, allowing users to integrate Coil with their specific version of the Ktor HTTP client. The public API for both modules now exposes \KtorNetworkFetcher\ and \KtorNetworkFetcherFactory\ classes, which provide factory methods to create network fetchers from an \io.ktor.client.HttpClient\ instance. These factories support optional configuration for concurrent request strategies, cache strategies, and connectivity checking, ensuring compatibility with the respective Ktor major versions.

coil-network-ktor2/api, coil-network-ktor3/api · high confidence

Stabilize Coil Core for Compose and fix R8 shrinking issues

Coil Core is now stable for the Compose compiler, allowing its classes to be used in Compose code without stability warnings. Additionally, R8 shrinking rules have been added to prevent a bug in R8 9.0+ that could drop super calls in GenericViewTarget subclasses, ensuring images render correctly in release builds.

coil-core · high confidence

Stabilize browser tests by disabling WASM streaming and increasing timeouts

To reduce flakiness in browser-based tests, the Karma configuration now patches WebAssembly.instantiateStreaming to compile from an ArrayBuffer instead, preventing Chrome stalls during large module loading. Additionally, test timeouts have been increased (Mocha to 60s, browser activity to 10 minutes) to accommodate slower WASM startup on local machines, and a custom ChromeHeadless launcher is used to disable extensions and randomize the remote debugging port for a more stable execution environment.

karma.browser.d · high confidence

Stabilize singleton image loader configuration in Compose

The \setSingletonImageLoaderFactory\ function is now stable, allowing developers to configure the global image loader used by \AsyncImage\, \rememberAsyncImagePainter\, and \SubcomposeAsyncImage\ via a Compose-optimized API. This change ensures that the singleton loader is set safely and immediately, preventing race conditions when these composables are invoked during composition.

coil-compose/src · high confidence

Stabilized Compose image APIs with new AsyncImage composable and crossfade support

The Coil Compose module has been restructured to stabilize its public API, introducing a new \AsyncImage\ composable that simplifies asynchronous image loading by handling request execution and state management internally. The existing \rememberAsyncImagePainter\ and \SubcomposeAsyncImage\ APIs have been updated to align with this new structure, including the addition of a \clipToBounds\ parameter to control content clipping. A new \CrossfadePainter\ has been added to enable smooth crossfade transitions between subsequent image results, configurable via the \useExistingImageAsPlaceholder\ request option. The release also introduces \ConstraintsSizeResolver\ and \DrawScopeSizeResolver\ for more flexible size resolution, exposes \LocalAsyncImageModelEqualityDelegate\ to control when image requests are re-executed on model changes, and provides \LocalAsyncImagePreviewHandler\ to customize rendering in Android Studio previews.

coil-compose-core/src/commonMain/kotlin/coil3/compose · high confidence

Stabilized Image APIs and introduced ColorImage for non-Android platforms

The Image APIs are now stabilized, removing experimental annotations and providing a consistent interface across all multiplatform targets. A new ColorImage class allows rendering solid color images, replacing the previous FakeImage implementation. Additionally, the ImageLoader execution is decoupled from the main dispatcher on non-Android platforms to improve performance, and transformations are now supported on all targets.

coil-core/src/nonAndroidMain/kotlin/coil3 · high confidence

Stabilized singleton image loader APIs and Android context handling

The Android-specific singleton image loader implementation is now stabilized, introducing an internal \PlatformContext.applicationContext()\ accessor to properly resolve the application context for singleton loaders. Additionally, extension functions for \Context\ and \ImageView\ (such as \imageLoader\, \load\, \dispose\, and \result\) are stabilized, providing a consistent and reliable way to load images and manage request lifecycles on Android without requiring manual singleton management.

coil/src/androidMain · high confidence

Updated coil-compose API signatures for Coil 3

The public API surface for coil-compose has been updated to reflect the Coil 3 release, introducing new function signatures for \AsyncImage\, \SubcomposeAsyncImage\, and \rememberAsyncImagePainter\. This change includes the addition of \setSingletonImageLoaderFactory\ for configuring the global image loader via CompositionLocal, and updates to the Klib ABI dump to support the new multiplatform targets (iosArm64, iosSimulatorArm64, js, macosArm64, wasmJs).

coil-compose/api · high confidence

Web image decoding now uses a background worker for improved UI responsiveness

Image decoding on the web platform has been refactored to run in a dedicated Web Worker, preventing the main UI thread from blocking during heavy image processing. This change introduces a new \SkiaImageDecoder\ implementation for the JS common target that leverages fast, header-based size extraction for PNG, JPEG, and WebP formats to determine dimensions before decoding. The actual pixel decoding is offloaded to a JavaScript-based worker that uses \createImageBitmap\ and \OffscreenCanvas\, transferring the resulting pixel data back to the main thread via \installPixelsFromArrayBuffer\. This architectural shift significantly improves application performance and responsiveness when loading images on web platforms.

coil-core/src/jsCommonMain/kotlin/coil3/decode · high confidence

Fixes

Fallback memory detection for Linux targets

A new Linux-specific implementation for \PlatformContext.totalAvailableMemoryBytes()\ has been added to \coil-core\. This change provides a hardcoded fallback value of 512 MB for total available memory on Linux platforms, ensuring that cache sizing logic does not fail when physical memory detection is unavailable or unsupported on these targets.

coil-core/src/linuxMain · high confidence

Restores missing executeBlocking method on JVM ImageLoader

The JVM-specific implementation of ImageLoader now includes the executeBlocking method, which was previously missing. This restores the ability to synchronously execute image loading requests on the JVM platform, ensuring binary compatibility and preventing runtime errors for code relying on this synchronous execution path.

coil-core/src/jvmCommonMain/kotlin/coil3 · high confidence

Workaround for Skiko ES module loading in Node.js

A new Node.js script has been added to intercept and transform Skiko ES module files (skiko.mjs, skikod8.mjs) during runtime. This workaround converts ES module syntax (such as import.meta.url and export statements) into CommonJS format, allowing these specific modules to be loaded correctly in environments that do not natively support ES modules.

gradle/nodejs · high confidence

Test coverage

Added API surface for JVM test utilities; Added Android device instrumented tests for Coil Compose and Core; Added Android host tests for FakeImageLoaderEngine and SingletonImageLoader; Added Android host tests for core image loading components; Added Android instrumentation tests for GIF animation and transformation features; Added JVM Common test utilities for SVG decoding; Added JVM-specific bitmap decoding utility for tests; Added Paparazzi snapshot tests for image loading components; Added Roborazzi snapshot tests for Android and JVM Compose/View integration; Added non-Android test utilities for bitmap comparison and platform context; Added test for ES module image decoding; Added test utilities for mocking image loading; Added test utility to ignore tests on Apple platforms; Added tests for AsyncImage model equality, constraint size resolution, and deferred dispatch; Added tests for BlackholeDecoder, DataUriFetcher, and DecodeUtils; Added tests for Blob URI fetching on JS/Wasm targets; Added tests for CacheControlCacheStrategy; Added tests for Compose UI resource loading; Added tests for CrossfadePainter and ImagePainter; Added tests for FakeImageLoaderEngine; Added tests for FileUriKeyer cache key generation; Added tests for HEIF support and updated GIF decoder service loader verification; Added tests for JVM file fetching and path mapping; Added tests for LruCache and LruMutableMap utilities; Added tests for NSURLMapper on Apple platforms; Added tests for PathMapper behavior; Added tests for SingletonImageLoader behavior; Added tests for VideoFrameServiceLoader; Added tests for memory cache implementations; Added tests for network caching, concurrent request strategies, and fetcher behavior; Added tests for the interceptor chain behavior; Added tests for video frame decoding and MediaDataSource support; Added tests for web image size extraction and Skiko module initialization; Added unit tests for Uri parsing and ImageLoader request handling; Added unit tests for disk caching components; New internal test utilities for network fetching and image comparison; Removal of bitmap pool strategy unit tests; Removal of legacy test utility functions; Removal of shared test utility functions; Removal of test-only BitmapPool fakes; Removed RealImageLoaderIntegrationTest; Removed ViewSizeResolverTest; Removed basic RealImageLoader tests; Removed instrumentation tests for BitmapFactoryDecoder and DrawableDecoderService; Removed legacy Robolectric-based fetcher tests; Removed legacy memory cache and target delegate tests; Removed lifecycle coroutine dispatcher tests and fakes; Removed unit tests for GroupedLinkedMap and SparseIntArraySet; Updated test utilities for non-Android platforms.

Dependencies

Gradle wrapper upgraded to v9.7.1 with enhanced network resilience

The Gradle wrapper has been updated from version 5.5.1 to 9.7.1, significantly modernizing the build toolchain. This upgrade introduces new configuration properties to improve build stability: network timeouts are now set to 10,000ms, retry logic is enabled with zero initial retries and a 500ms back-off delay, and distribution URL validation is enforced. These changes ensure more robust dependency downloads and stricter integrity checks during the build process.

gradle/wrapper · 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 54 → 56 (+2.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 45 → 45 (-0.0)
  • Architecture 96 → 96 (+0.2)
  • Maturity 62 → 63 (+0.7)
  • Readiness 50 → 52 (+2.4)
  • Security 78 → 94 (+16.3)
  • Performance 83 → 94 (+11.4)

Resolved (19)

  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Documentation: contradicts the code (docs/upgrading_to_coil3.md)
  • Duplicated block (11 lines × 2) (coil-core/src/androidMain/kotlin/coil3/ColorImage.kt)
  • Duplicated block (16 lines × 2) (coil-core/src/commonMain/kotlin/coil3/decode/DecodeUtils.kt)
  • Duplicated block (17 lines × 2) (coil-network-ktor2/src/jvmCommonMain/kotlin/coil3/network/ktor2/internal/utils.jvmCommon.kt)
  • Duplicated block (23 lines × 2) (coil-core/src/jsCommonMain/kotlin/coil3/decode/SkiaImageDecoder.jsCommon.kt)
  • Duplicated block (33 lines × 2) (coil-core/src/androidMain/kotlin/coil3/decode/StaticImageDecoder.kt)
  • Duplicated block (56 lines × 2) (coil-network-ktor2/src/commonMain/kotlin/coil3/network/ktor2/KtorNetworkFetcher.kt)
  • Duplicated block (61 lines × 2) (coil-network-ktor2/src/commonMain/kotlin/coil3/network/ktor2/internal/utils.kt)
  • High CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
  • High CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
  • High CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
  • High CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
  • High CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
  • High secret: WD-SECRET-0004 (.github/debug.keystore)
  • Inconsistent method naming for setting the singleton loader. 'setSafe' and 'setUnsafe' imply a safety distinction, but both 'setUnsafe' overloads exist for different input types (ImageLoader vs Factory). This is confusing because 'setSafe' only takes a Factory, while 'setUnsafe' takes either. It is unclear why one path is 'safe' and the other 'unsafe' without documentation, and the naming doesn't clearly distinguish between setting a raw instance vs a factory.
  • Inconsistent naming convention for request builder methods. Most methods use the property name directly (e.g., videoFrameIndex, videoFramePercent), but one method appends 'Key' to the name (preferVideoFrameEmbeddedThumbnailKey). This breaks the fluent naming pattern.
  • Inconsistent time unit naming in builder methods. One method uses 'Millis' while the other uses 'Micros', despite both being time-based frame selection options. This forces users to remember specific unit names rather than having a consistent pattern (e.g., videoFrameTime or videoFrameTimestamp).
  • Leaked secret: private-key-store (.github/debug.keystore)

New (477)

  • Duplicated block (11 lines × 2) (coil-core/src/androidMain/kotlin/coil3/ColorImage.kt)
  • Duplicated block (13 lines × 3) (coil-compose/src/commonMain/kotlin/coil3/compose/SingletonAsyncImage.kt)
  • Duplicated block (15 lines × 2) (coil-compose/src/commonMain/kotlin/coil3/compose/SingletonAsyncImage.kt)
  • Duplicated block (15–16 lines × 2) (coil-core/src/androidMain/kotlin/coil3/size/ScaleDrawable.kt)
  • Duplicated block (16 lines × 2) (coil-core/src/commonMain/kotlin/coil3/decode/DecodeUtils.kt)
  • Duplicated block (17 lines × 2) (coil-network-ktor2/src/jvmCommonMain/kotlin/coil3/network/ktor2/internal/utils.jvmCommon.kt)
  • Duplicated block (23 lines × 2) (coil-core/src/jsCommonMain/kotlin/coil3/decode/SkiaImageDecoder.jsCommon.kt)
  • Duplicated block (33 lines × 2) (coil-core/src/androidMain/kotlin/coil3/decode/StaticImageDecoder.kt)
  • Duplicated block (56 lines × 2) (coil-network-ktor2/src/commonMain/kotlin/coil3/network/ktor2/KtorNetworkFetcher.kt)
  • Duplicated block (61 lines × 2) (coil-network-ktor2/src/commonMain/kotlin/coil3/network/ktor2/internal/utils.kt)
  • Edited copies of one member (3 members, 15+ corresponding lines) (coil-compose/src/commonMain/kotlin/coil3/compose/SingletonAsyncImage.kt)
  • Edited copies of one member (4 members, 12+ corresponding lines) (coil-compose-core/src/commonMain/kotlin/coil3/compose/internal/ContentPainterModifier.kt)
  • Edited copy of a member (12 corresponding lines) (coil-compose/src/commonMain/kotlin/coil3/compose/SingletonAsyncImage.kt)
  • Edited copy of a member (13 corresponding lines) (coil-compose-core/src/commonMain/kotlin/coil3/compose/AsyncImage.kt)
  • Edited copy of a member (13 corresponding lines) (coil-compose-core/src/commonMain/kotlin/coil3/compose/AsyncImage.kt)
  • Edited copy of a member (14 corresponding lines) (coil-core/src/androidMain/kotlin/coil3/request/RequestService.android.kt)
  • Edited copy of a member (16 corresponding lines) (coil-core/src/androidMain/kotlin/coil3/decode/StaticImageDecoder.kt)
  • Edited copy of a member (26 corresponding lines) (coil-compose-core/src/androidMain/kotlin/coil3/compose/AsyncImagePainter.android.kt)
  • Edited copy of a member (27 corresponding lines) (coil-core/src/androidMain/kotlin/coil3/size/ScaleDrawable.kt)
  • Edited copy of a member (44 corresponding lines) (coil-core/src/androidMain/kotlin/coil3/decode/StaticImageDecoder.kt)
  • …and 457 more

Changes since last survey

  • 26 commits — 24 feature/other, 2 fixes

By area

  • gradle/libs.versions.toml — 10 commits
  • (root) — 7 commits
  • coil-core/src — 3 commits
  • gradle/wrapper — 2 commits
  • buildSrc/src — 1 commit
  • coil-compose/README.md — 1 commit
  • coil-network-httpengine/src — 1 commit
  • internal/benchmark — 1 commit

Notable commits

  • fix: Fix Windows drive-letter parsing (#3660)
  • fix: Fix edge case in RealImageLoaderAndroidTest. (#3644)
  • change: Add coil-network-httpengine module (#3659)
  • change: Enforce JS/WASM test max parallism in Gradle (#3658)
  • change: Migrate screenshot tests to Android test suite support (#3590)
  • change: Pin the NDK and exclude duplicate test resources (#3643)
  • change: Remove obsolete painter benchmark metric (#3645)
  • change: Update Gradle to v9.9.0 (#3651)
  • change: Update Gradle to v9.9.1 (#3661)
  • change: Update dependency androidx.test.uiautomator:uiautomator to v2.4.1 (#3647)
  • change: Update dependency com.android.tools.build:gradle to v9.5.0 (#3636)
  • change: Update dependency com.android.tools.build:gradle to v9.5.1 (#3648)
  • change: Update dependency mkdocs-material to v9.8.0 (#3635)
  • change: Update dependency mkdocs-material to v9.8.1 (#3652)
  • change: Update dependency org.jetbrains.dokka:dokka-gradle-plugin to v2.3.0 (#3650)
  • change: Update dependency org.jetbrains.kotlinx:kotlinx-io-okio to v0.9.2 (#3640)
  • change: Update dependency org.jetbrains.kotlinx:kotlinx-serialization-json to v1.13.0 (#3663)
  • change: Update dependency pymdown-extensions to v13 (#3654)
  • change: Update dependency pymdown-extensions to v13.1 (#3664)
  • change: Update documentation for current APIs (#3666)
  • …and 6 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 1 added · 0 removed

Added bounded contexts (1)

  • coil-network-httpengine

Added dependency edges (1)

  • coil-network-httpengine → coil-core

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

Survey your own repository

coil-kt/coil 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 e89c927c18c7141a3ac46218a30dfe59987f8e77 — 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.63+preprod-4a8cc97a9484.