coil-kt/coil

This system is Coil 3, a Kotlin Multiplatform image loading library that provides a unified API for loading, caching, and displaying images across Android, iOS, JVM, JS, and WebAssembly targets. It features a modernized, Compose-centric architecture with native support for animated GIFs, SVGs, and video frame extraction, while offering extensible network integration via OkHttp and Ktor. The library manages image lifecycle, memory, and disk caching through a stable singleton pattern and supports advanced features like HTTP cache control and crossfade transitions.

41 changes.

This period focused on a major architectural overhaul of the Coil library, removing legacy builder-based APIs, singleton patterns, and internal implementation details in favor of a unified ImageRequest model and explicit initialization. The release also included significant infrastructure updates, such as migrating the sample app to modern Android components, upgrading the Gradle wrapper, and introducing a Bill of Materials for dependency management.

69 changes.

This period focused on the development and stabilization of Coil 3, establishing a comprehensive Kotlin Multiplatform architecture with support for JVM, Android, iOS, JS, and WebAssembly. The work involved defining stable public APIs for core image loading, Compose integration, and specialized modules for GIF, video, and SVG handling, while introducing a new extensible network layer. Extensive testing infrastructure, including snapshot and instrumentation tests, was built to ensure cross-platform compatibility and performance.

8 changes.

This period focused on enabling ES module compatibility in Node.js and verifying image decoding in JS environments, alongside migrating the Android sample to the new KMP Gradle plugin. Significant effort was also directed at stabilizing browser tests by addressing WASM loading issues and expanding test coverage for Android Compose components and lint rules.

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

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

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

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

The shared sample module now includes core data models and view-model logic to support image and video display. A new Image data class carries URI, dimensions, color, and Coil 3 extras (such as video frame timestamps). The MainViewModel manages navigation between a list and detail screen, loads images from JSON resources, and generates synthetic video frames with associated metadata. The Screen sealed interface defines List and Detail states, with Detail carrying the selected image and an optional Coil memory-cache placeholder key.

shared · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The Coil Compose API for JVM has been significantly restructured to enhance image handling and developer experience. Users can now enable smooth crossfade transitions between subsequent image results via the public CrossfadePainter, and manually restart image loading using the new AsyncImagePainter.restart() method. The AsyncImage and SubcomposeAsyncImage composables now support disabling clipToBounds for more flexible layout control. Additionally, image requests in Android Studio previews are handled via the new LocalAsyncImagePreviewHandler composition local, and model equality is customizable through the AsyncImageModelEqualityDelegate composition local. The API also exposes ConstraintsSizeResolver and DrawScopeSizeResolver for advanced sizing control.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, karma.config.d · high confidence

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

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

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

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

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

Add Android device instrumentation tests for coil-core; Add Compose screenshot tests for AsyncImage and vector drawables; Added API surface for JVM test utilities; Added Android host tests for image loading and composition components; Added Android instrumentation tests for GIF animation and transformation features; Added Android instrumented tests for Coil Compose; 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 CacheControlCacheStrategy; Added tests for Compose UI resource loading; Added tests for FakeImageLoaderEngine; Added tests for HEIF support and updated GIF decoder service loader verification; Added tests for SingletonImageLoader behavior; Added tests for VideoFrameServiceLoader; Added tests for network caching, concurrent request strategies, and fetcher behavior; Added tests for video frame decoding and MediaDataSource support; 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.

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 36 → 53 (+17.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 52 → 48 (-3.4)
• Architecture 97 → 100 (+2.9)
• Maturity 49 → 63 (+14.4)
• Readiness 15 → 46 (+30.8)
• Security 60 → 73 (+12.9)

• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
• Critical CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
• Dimension evaluation failed
• Duplicated block (34 lines × 2) (coil-core/src/commonMain/kotlin/coil3/decode/DecodeUtils.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 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 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)
• …and 65 more

• AbstractContentPainterNode.modifyConstraints (cognitive 17) (coil-compose-core/src/commonMain/kotlin/coil3/compose/internal/ContentPainterModifier.kt)
• Change coupling: AsyncImage.kt ↔ SubcomposeAsyncImage.kt (coil-compose-core/src/commonMain/kotlin/coil3/compose/AsyncImage.kt)
• Change coupling: ScaleDrawable.kt ↔ CrossfadeDrawable.kt (coil-core/src/androidMain/kotlin/coil3/size/ScaleDrawable.kt)
• ClassTooLong: DiskLruCache (coil-core/src/commonMain/kotlin/coil3/disk/DiskLruCache.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• DiskLruCache.completeEdit (cognitive 20) (coil-core/src/commonMain/kotlin/coil3/disk/DiskLruCache.kt)
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Documentation: written for insiders (docs/java_compatibility.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 (49 lines × 2) (coil-core/src/androidMain/kotlin/coil3/EventListener.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)
• ErrorFunctionDetector.isInsideImageRequestBuilderLambda (cognitive 41) (coil-lint/src/main/kotlin/coil3/lint/ErrorFunctionDetector.kt)
• High CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
• …and 68 more

• 63 commits — 59 feature/other, 4 fixes

• gradle/libs.versions.toml — 25 commits
• (root) — 20 commits
• coil-core/src — 9 commits
• gradle/wrapper — 2 commits
• (repo) — 1 commit
• .github/workflows — 1 commit
• buildSrc/src — 1 commit
• coil-bom/build.gradle.kts — 1 commit
• coil-network-core/src — 1 commit
• internal/test-js-es-modules — 1 commit
• samples/view — 1 commit

• fix: Fix JS ES module test configuration (#3560)
• fix: Fix Skiko bridge for ES module consumers (#3558)
• fix: Fix android test source sets to androidHostTest and androidDeviceTest (#3597)
• fix: Fix deduplicated request cancellation handling (#3566)
• change: Adds support for loading images from blob URLs (object URLs) on web (JS/Wasm) targets (#3504)
• change: Avoid internal Skiko APIs on web (#3534)
• change: Enable suppressAgpWarnings. (#3535)
• change: Fix formatting.
• change: Group Compose Multiplatform and Skiko dependency updates (#3538)
• change: Merge pull request #3591 from coil-kt/release/3.6
• change: Migrate to AGP's new DSL. (#3567)
• change: Migrate to Bitmap.installPixelsFromArrayBuffer for decoding images on web. (#3536)
• change: Prepare 3.6.0.
• change: Prepare next development version.
• change: Prepare next development version.
• change: Prepare next development version.
• change: Prepare next development version.
• change: Prepare version 3.6.1.
• change: Prepare version 3.6.2.
• change: Prepare version 3.6.3.
• …and 43 more

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

• coil-compose-core
• coil-core
• coil-gif
• coil-svg
• shared

• coil-compose-core → coil-core (coupling)
• coil-gif → coil-core
• coil-svg → coil-core
• shared → coil-core

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

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.