Skip to content
CAI
Software that uses CAICheck a score

JetBrains/compose-multiplatform

61.6

Adequate · 13 November 2026

69.3k

lines of production code

Kotlin

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Android issues example app entry point

The Android issues example application now includes a main activity that initializes the GitHub issues viewer. This activity sets up the Compose UI by providing a repository instance via CompositionLocal, allowing users to view and interact with GitHub issues directly within the app.

examples/issues/android/src/main/java · high confidence

Add Android-specific placeholder for vertical scrollbar in JetIssues example

The JetIssues example now includes an Android-specific implementation for the vertical scrollbar component. A new AndroidManifest.xml and a Platform.kt file define an actual function for VerticalScrollbar that currently performs no operation (Unit), serving as a stub to satisfy the common interface while the feature is likely under development or disabled on Android.

examples/issues/common/src/androidMain · high confidence

Add AnimatedImage component for desktop

Introduces a new AnimatedImage component for the desktop platform, allowing users to load and display animated images from local files, resources, or network URLs. The implementation uses Skia codecs to decode frame sequences and Compose animations to render each frame, with automatic handling of frame durations and caching of loaded image data.

components/AnimatedImage/library · high confidence

Add AnimatedImage demo application

A new demo application has been added for the AnimatedImage component, demonstrating how to load animated images from a URL and display them using the \loadAnimatedImage\ and \animate\ APIs. The demo includes a main window that shows a large animated image with loading and error states, as well as a smaller 100dp instance.

components/AnimatedImage/demo · high confidence

Add Apple platform support to multiplatform benchmarks

Benchmarks can now run on Apple platforms (iOS/macOS). This adds platform-specific implementations for the graphics context using Metal, enables saving benchmark results to JSON on disk, provides a method to measure process start time, and allows manual garbage collection triggering.

benchmarks/multiplatform/benchmarks/src/appleMain · high confidence

Add Code Viewer example for Desktop, Android, and iOS

Introduces a new Code Viewer example application built with Compose Multiplatform, supporting Desktop, Android, and iOS targets. The addition includes the necessary project scaffolding, such as a .gitignore file, an Apache 2.0 LICENSE.txt, a README with setup and run instructions, and Gradle wrapper scripts (gradlew and gradlew.bat) to facilitate building and running the example on various platforms.

examples/codeviewer · high confidence

Add Compose HTML hydration example

The Compose HTML EAP now includes a hydration example demonstrating server-side rendering with client-side interactivity. The example shows how to render an initial HTML document on the JVM using \renderHydratedDocument\ and \HydrationRoot\, and then adopt that existing DOM in the browser using \hydrateRoot\, allowing state to cross the boundary between server and client.

html/eap/examples/hydration, hydration · high confidence

Add Compose Web HTML library template

Introduces a new template for Compose Web applications in the CI templates directory. This template provides a minimal HTML library project structure, including a Kotlin entry point that renders a Compose UI with a clickable counter, an HTML host page, and Gradle wrapper scripts (version 8.13) to build and run the application in a browser.

ci/templates/html-library-template · high confidence

Add GitHub issues data layer with UI state management

The issues example now includes a shared data layer for fetching GitHub repository issues. This introduces a \UiState\ sealed class and a \uiStateFrom\ composable helper to manage loading, success, and error states in the UI. The \IssuesRepository\ implementation connects to the GitHub GraphQL API using Apollo Client, handling authentication and parsing issue data for both open and closed states.

examples/issues/common/src/jvmAndAndroidMain/kotlin/androidx/ui/examples/jetissues/data · high confidence

Add Graphics2D example with multi-platform support

The examples/graphics-2d directory now includes a complete Graphics2D example project that can run on Android, iOS, desktop, and in a browser. This addition includes the necessary project scaffolding such as a .gitignore file for local and iOS build artifacts, an Apache 2.0 license file, a README with setup and run instructions, and Gradle wrapper scripts for both POSIX and Windows environments.

examples/graphics-2d · high confidence

Add JDK version probe utility for desktop packaging

A new JdkVersionProbe utility has been added to the Gradle plugins to detect the major JDK version and vendor. This tool supports modern JDK versioning APIs (Java 9+) with a fallback to legacy string parsing for older versions, enabling the build system to accurately identify the runtime environment used for desktop application packaging.

gradle-plugins/jdk-version-probe · high confidence

Add JavaScript-specific resource loading and XML parsing implementations

This change introduces the JavaScript platform implementations for the Compose Resources library, enabling vector image (XML) parsing and raw resource reading on web targets. It adds \ImageResources.js.kt\ to handle XML-to-Element conversion using the browser's DOMParser, \ResourceReader.js.kt\ to convert browser Blobs into byte arrays for resource loading, and \NodeImpl.kt\ to provide a DOM-based Node abstraction for XML tree traversal. These files complete the resource reading infrastructure for the JS/WasmJs targets, allowing applications to load vector drawables and other resources at runtime.

components/resources/library/src/jsMain · high confidence

Add JetIssues example GraphQL schema and queries

The JetIssues example now includes the necessary GraphQL assets to interact with the GitHub API. A new \issues.graphql\ file defines queries for fetching issue lists (with pagination, filtering, and label details) and individual issue bodies, while a \schema.json\ file provides the corresponding type definitions. These additions enable the example application to correctly fetch and display repository issue data.

examples/issues/common/src/commonMain · high confidence

Add Kotlin/Wasm support to the Compose Resources library

The Compose Resources library now supports the Kotlin/Wasm target, enabling resource loading in WebAssembly environments. This includes implementations for reading resources from blobs into byte arrays using optimized linear memory access, parsing XML resources (such as vector drawables) via the browser's DOMParser, and providing the necessary DOM node abstractions required for XML processing on the Wasm platform.

components/resources/library/src/wasmJsMain · high confidence

Add Maven-based compatibility test project for Compose Multiplatform

A new test project has been added to the CI templates to verify that Compose Multiplatform dependencies are correctly resolvable via Maven POM files, a requirement for JetBrains IntelliJ Platform (JPS) users. The project includes a Kotlin source file using Material3 components and a shell script that builds and runs the application, specifically configured to fail the build if any Maven dependency warnings are detected.

ci/templates/maven-test-project · high confidence

Add XML Vector Drawable support for macOS native targets

Users can now use XML vector drawables on macOS native applications. This change introduces a new \DomXmlParser\ implementation for the \nativeMain\ source set, leveraging the platform's native \NSXMLParser\ to parse XML resources, thereby extending vector image support to the macOS target.

components/resources/library/src/nativeMain/kotlin/org/jetbrains/compose/resources/vector · high confidence

Add desktop MapView example with OpenStreetMap integration

The ImageViewer example now includes a desktop MapView component that renders Earth tile maps using the OpenStreetMap API. This addition introduces a full implementation for handling map interactions, including panning, zooming (via scroll and click), and tile loading. The feature relies on a custom state management system (LibStore), a repository pattern for fetching and caching map tiles (with disk caching and parallel request limiting), and coordinate conversion utilities for geographic and display points. Users can now view and interact with map data within the desktop example application.

examples/imageviewer/mapview-desktop, mapview-desktop · high confidence

Add desktop preview configuration task

The Compose Desktop Gradle plugin now registers a \configureDesktopPreview\ task for each JVM target, automatically wiring the necessary runtime Jars and Skiko runtime provider so that preview configuration is handled without manual setup.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/preview · high confidence

Add iOS SwiftUI-in-Compose interop example project

The iosApp directory now contains a complete Xcode project demonstrating how to embed a Compose Multiplatform UI within a native SwiftUI application. The example includes the necessary Swift source files (iOSApp.swift, ContentView.swift, ComposeViewControllerRepresentable.swift) and configuration files to build the app, allowing users to see how ComposeViewControllerRepresentable bridges the two frameworks.

examples/interop/ios-swiftui-in-compose/iosApp · high confidence

Add iOS example app for UIKIt-in-Compose interop

The \iosApp\ directory now contains a complete, buildable Xcode project that demonstrates embedding a Compose for Desktop application within an iOS app using UIKit. The example includes the necessary Swift entry points (\iOSApp.swift\, \ContentView.swift\) to host the Compose view via \UIViewControllerRepresentable\, an \Info.plist\ for app configuration, and a \Config.xcconfig\ file to define the bundle identifier and team settings. This provides a concrete reference implementation for developers looking to integrate Kotlin Multiplatform Compose UIs into existing iOS native applications.

examples/interop/ios-uikit-in-compose/iosApp · high confidence

Add iOS interop examples for UIKitView usage

The shared module now includes example code demonstrating how to embed native UIKit components within Compose Multiplatform. Specifically, it adds a reusable composable for a UITextField that syncs its text state with Compose, and updates the main entry point to display both a MapKit MKMapView and the text field, each styled with a blue border to illustrate layout and styling within the interop context.

examples/interop/ios-uikit-in-compose/shared · high confidence

Add iOS native app wrapper for the Graphics2D example

The Graphics2D example now includes a complete iOS application project (iosApp) that wraps the shared Kotlin/Compose code. This adds an Xcode project configuration, Swift UI entry points, and asset catalogs, enabling users to build and run the 2D graphics demo directly on iOS devices.

examples/graphics-2d/iosApp · high confidence

Add iOS native wrapper for the ImageViewer example

The ImageViewer example now includes a native iOS application entry point. This adds the necessary SwiftUI app structure (iOSApp.swift, ContentView.swift) and asset catalogs (AppIcon, AccentColor) to wrap the existing Compose-based image viewer, allowing users to run and test the example directly on iOS devices.

examples/imageviewer/iosApp/iosApp · high confidence

Add iOS target to multiplatform benchmarks

Developers can now run Compose benchmarks on iOS devices and simulators. This change introduces the \iosApp\ Xcode project, Swift entry points, and a \run\_ios\_benchmarks.sh\ script that builds the app, installs it on a target, and executes benchmarks with configurable parallelism and attempts, saving results to the \benchmarks\_result\ directory.

benchmarks/multiplatform/iosApp · high confidence

Add iOS-specific resource files and entry point for the resources demo

The iOS demo module now includes a platform-specific text resource (platform-text.txt) and a Kotlin entry point (main.ios.kt) that launches the shared UseResources composable via ComposeUIViewController, enabling the resources demo to run on iOS.

components/resources/demo/shared/src/iosMain · high confidence

Add issues example with build and license scaffolding

The \examples/issues\ directory now includes a complete project scaffold for a GitHub Issues viewer built with Jetpack Compose. This addition provides the necessary infrastructure for users to run and build the example, including a README with instructions for launching the desktop application and creating native distributions, a Gradle wrapper for consistent builds, and an Apache 2.0 license file copied from the root directory.

examples/issues · high confidence

Add nav\_cupcake Compose Multiplatform example

A new example project, nav\_cupcake, is available to demonstrate navigation between screens using Compose Multiplatform. Adapted from the Android codelab, this example includes the full source code and build configuration for both desktop and iOS targets, allowing users to run and study the navigation implementation on these platforms.

_examples/nav\cupcake · high confidence

Add preview annotation demo for desktop and shared modules

A new demo application has been added to showcase the usage of the \@Preview\ annotation in Compose. The shared module introduces a \UsePreviewAnnotation\ composable that wraps a common main function (\UsedInPreview\), while the desktop app module provides a standalone window entry point (\Main.kt\) to render this preview content, allowing users to verify preview functionality in a desktop environment.

components/ui-tooling-preview/demo/desktopApp, components/ui-tooling-preview/demo/shared · high confidence

Add server-side string rendering example for Compose HTML

An example application demonstrating Compose HTML's server-side string rendering capability has been added. This example shows how to use \composeHtmlToString\ to generate a complete HTML document on the server, which is then written to a file and opened in a browser, highlighting benefits like zero JavaScript requirements and HTML-first SSR.

string-rendering · high confidence

Add web-based benchmark runner for V8/D8 environments

The benchmark suite now supports running benchmarks in web environments using the V8/D8 engine. This change introduces a new \webMain\ source set containing the Kotlin entry point (\Main.web.kt\) that initializes the Compose viewport and runs benchmarks, along with a \runGC.web.kt\ implementation for manual garbage collection. It also includes the necessary web resources: an HTML entry point, CSS styles, and JavaScript modules (\launcher.mjs\, \launcher\_jetstream3.mjs\, and \polyfills.mjs\) that provide browser API polyfills and orchestrate the benchmark execution within the D8 shell.

benchmarks/multiplatform/benchmarks/src/webMain · high confidence

Added CI tooling for building a Compose Uber JAR

This change introduces a new Gradle-based build setup in the \ci/compose-uber-jar\ directory, enabling the creation of a single 'uber jar' (\compose-full.jar\) that merges all \org.jetbrains.compose\*\ artifacts. The addition includes the Gradle wrapper (version 8.13), build scripts, and documentation, allowing users to locally build the merged artifact via \./gradlew shadowJar\ or publish it to a repository using provided credentials.

ci/compose-uber-jar · high confidence

Added Compose for Web sample application and integration tests

The html/integration-core module now includes a comprehensive sample application and a suite of integration tests. The sample app demonstrates various Compose for Web capabilities, including stateful UI components like counters, input handling for text, checkboxes, and radio groups, CSS styling with keyframes and media queries, and syntax highlighting via Highlight.js. Alongside the sample, a new test harness and a large set of Selenium-based integration tests have been added to verify the behavior of controlled and uncontrolled inputs, event handling (such as clicks, focus, scroll, and mouse events), and UI element interactions.

html/integration-core · high confidence

Added D8 runtime preparation for WebAssembly benchmarks

A new Gradle script (wasm-d8-runtime.gradle.kts) has been added to the benchmarks/multiplatform/gradle directory to support running benchmarks in the D8 JavaScript engine. This script registers tasks to prepare the WebAssembly runtime by patching import paths and modifying the Skiko WASM loading logic to use pre-loaded binary bytes instead of dynamic instantiation. It also defines a 'buildD8Distribution' task to package the prepared production runtime into a zip file. Additionally, the Gradle wrapper has been updated to version 9.3.1.

benchmarks/multiplatform/gradle · high confidence

Added Gradle wrapper and build scaffolding for the JetBrains Compose Gradle plugin

The gradle-plugins directory now includes the standard Gradle wrapper scripts (gradlew, gradlew.bat), a .gitignore file, and a README describing the plugin's environment variables. This change establishes the build infrastructure for the JetBrains Compose Gradle plugin, allowing it to be built and run independently using the bundled Gradle version.

gradle-plugins · high confidence

Added Jetpack Compose for Desktop paragraph rendering benchmark

A new benchmark module for Jetpack Compose on Desktop has been introduced in the benchmarks/desktop directory. This module uses kotlinx-benchmark to measure the performance of paragraph layout and rendering, specifically testing text styling features such as fonts, colors, shadows, and span styles via a JMH benchmark class.

benchmarks/desktop · high confidence

Added SplitPane demo application

A new demo application has been added for the SplitPane component, showcasing both horizontal and vertical split panes. The demo includes an action panel that allows users to freeze or unfreeze splitter movement, adjust splitter positions using raw delta values, and set specific position percentages, providing a practical example of the component's capabilities.

components/SplitPane/demo · high confidence

Added confirmation dialog for package deletion

A new Groovy-based Swing dialog has been introduced in the build source to require explicit user confirmation before deleting packages from Space. This component presents a modal window listing the packages to be removed and waits for the user to click either 'Confirm' or 'Cancel', ensuring that deletion actions are intentional.

ci/delete-packages-from-space/buildSrc · high confidence

Added desktop application template with Gradle 8.13 and Compose UI

The desktop-template location now includes a complete, runnable Kotlin desktop application scaffold. This adds a Gradle wrapper configured for Gradle 8.13, standard build configuration files (.gitignore, run configurations), and a main source file (main.kt) that initializes a Compose Desktop window displaying a Material Theme button. Users can now use this template to quickly start a new desktop project using the latest Gradle wrapper and Compose UI components.

ci/templates/desktop-template · high confidence

Added iOS Compose in SwiftUI example project

The repository now includes a new example project at examples/interop/ios-compose-in-swiftui that demonstrates how to integrate Compose Multiplatform into an iOS application built with SwiftUI. The entry point for the Compose UI is defined in main.ios.kt, and the Swift entry point is ContentView.swift. The addition includes standard project scaffolding such as the Gradle wrapper scripts (gradlew, gradlew.bat), a .gitignore file, and an Apache 2.0 LICENSE.txt.

examples/interop/ios-compose-in-swiftui · high confidence

Added iOS SwiftUI in Compose Multiplatform example

The repository now includes a new example project at examples/interop/ios-swiftui-in-compose that demonstrates how to integrate a SwiftUI view within a Compose Multiplatform application. This addition provides the necessary project scaffolding, including a README explaining the integration points (specifically main.ios.kt and ComposeViewControllerRepresentable.swift), a local .gitignore configuration for iOS development artifacts, and the Apache 2.0 license file.

examples/interop/ios-swiftui-in-compose · high confidence

Added iOS example demonstrating Compose Multiplatform integration with SwiftUI

The \iosApp\ directory now contains a complete Xcode project that serves as a reference for embedding Compose Multiplatform content within a native SwiftUI application. The example features a tabbed interface where one tab displays a Compose UI layer (wrapped in a \UIViewControllerRepresentable\) overlaid with a SwiftUI text input field, while the second tab shows a standard SwiftUI view. It includes the necessary build configuration, including a shell script to embed the Compose framework via Gradle, and Swift source files that illustrate the interop pattern.

examples/interop/ios-compose-in-swiftui/iosApp · high confidence

Added iOS interop example project scaffolding

The \examples/interop/ios-uikit-in-compose\ directory now includes the necessary project scaffolding to run the example, including a \.gitignore\ file to exclude local build artifacts, an Apache 2.0 \LICENSE.txt\, a \README.md\ explaining how to use \UIKitView\ in Compose Multiplatform, and the standard Gradle wrapper scripts (\gradlew\, \gradlew.bat\) for building the project.

examples/interop/ios-uikit-in-compose · high confidence

Added iOS interop example projects for Compose in SwiftUI and UIKit

New example projects have been added to demonstrate embedding Jetpack Compose within native iOS applications. The \ios-compose-in-swiftui\ example provides a Kotlin entry point that launches a Compose UI via \ComposeUIViewController\, while the \ios-compose-in-uikit\ example includes a similar setup but also imports \UIKitView\, illustrating how Compose can interact with UIKit views. Both examples feature a basic Material Theme layout with system bar insets and dark mode support, serving as starting templates for developers integrating Compose into existing iOS codebases.

examples/interop/ios-compose-in-swiftui/shared, examples/interop/ios-compose-in-uikit/shared · high confidence

Added image assets for the image viewer demo

The image viewer repository now includes a set of 13 sample images (1.jpg through 13.jpg) along with their small variants, defined in a new \pictures.json\ manifest and a \fetching.list\ file. This provides the necessary media assets for the image viewer component to display and navigate through a gallery of pictures.

artwork/imageviewerrepo · high confidence

Added initial scaffolding for desktop and iOS chat example apps

New example application files have been added to support desktop and iOS platforms. The desktop entry point (Main.kt) initializes a Compose window titled "Chat" with a fixed size, while the iOS configuration (Config.xcconfig) sets up the bundle identifier and app name for the project.

examples/chat/desktopApp, examples/chat/iosApp/Configuration · high confidence

Added internal XML DOM interfaces for vector drawable parsing

The resources library now includes a set of internal interfaces (Element, Node, NodeList) and a MalformedXMLException class within the vector/xmldom package. These additions provide the foundational DOM structures required to parse XML Vector Drawables, enabling the library to process vector image resources.

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources/vector/xmldom · high confidence

Adds desktop vertical scrollbar implementation

The JetIssues example now includes a concrete implementation of the vertical scrollbar for the desktop platform. This change adds a new \Platform.kt\ file that provides the \actual\ function for \VerticalScrollbar\, utilizing Compose Foundation's \VerticalScrollbar\ and \rememberScrollbarAdapter\ to enable scrolling UI components on desktop environments.

examples/issues/common/src/desktopMain · high confidence

Android app structure and configuration for the Image Viewer example

The Image Viewer example now includes the necessary Android application files to run on Android devices. This adds the AndroidManifest.xml declaring required permissions (Internet, Network State, External Storage) and configuring the main activity, the MainActivity.kt file which sets up the Compose UI entry point, and the themes.xml defining the app's visual style. These changes enable the example to be built and launched as a standalone Android application.

examples/imageviewer/androidApp · high confidence

Android application entry point and resources added to multiplatform template

The Android module of the multiplatform template now includes the necessary application entry point and resources. A new \AndroidManifest.xml\ defines the main activity and launcher intent, while \MainActivity.kt\ initializes the Compose UI. Standard Android resources, including adaptive launcher icons and app strings, have been added to support building and running the Android target.

ci/templates/multiplatform-template/android · high confidence

Android image storage implementation added

The ImageViewer example now includes a concrete Android-specific implementation for image storage. This new \AndroidImageStorage\ class handles persisting camera-captured images and thumbnails to local files, manages metadata serialization, and provides functionality to generate URIs for sharing images via Android's FileProvider.

examples/imageviewer/shared/src/androidMain/kotlin/example/imageviewer/storage · high confidence

Android platform implementation for the ImageViewer example

The ImageViewer example now includes a complete Android-specific implementation, enabling users to run the app on Android devices. This adds native support for taking photos via the CameraX API (including front/back camera toggling and permission handling), applying image filters (grayscale, pixel, and blur) using Android graphics APIs, and sharing images with descriptions via the system share sheet. It also integrates Google Maps for location visualization, provides a scrollable gallery grid, and handles platform-specific UI behaviors like touch scrolling and zoom controls.

examples/imageviewer/shared/src/androidMain/kotlin/example/imageviewer/view · high confidence

Android support added to multiplatform benchmarks

The multiplatform benchmarking tool now includes Android-specific implementations, allowing benchmark execution on Android devices. This change introduces Android source sets for saving benchmark statistics, handling time sources, and providing no-op implementations for graphics context and composable measurement (since Android requires the REAL mode via BenchmarkRunner). It also adds Skiko-based implementations for measuring composables with precise timing and GPU synchronization, along with version-specific scene implementations to support both older (≤1.11.x) and newer (≥1.12.0) Compose Multiplatform APIs.

(repo-wide) · high confidence

Android-specific image handling and sharing support added to ImageViewer example

The ImageViewer example now includes Android-specific implementations to support image processing and sharing features on Android devices. This adds a platform-specific module that converts byte arrays to ImageBitmaps using Android's BitmapFactory, defines a FileProvider for secure file access, and implements the share functionality with a dedicated icon and dispatcher support.

examples/imageviewer/shared/src/androidMain/kotlin/example/imageviewer · high confidence

Automatic JS/WASM fallback for web builds

The Gradle plugin now includes a new \composeCompatibilityBrowserDistribution\ task that bundles JavaScript and WebAssembly outputs together. This task generates a small resolver script that detects browser support for modern WebAssembly features; if supported, it loads the WASM module, otherwise it falls back to the JavaScript bundle. This ensures web applications run correctly on older browsers that lack full WASM support without requiring manual configuration from the user.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/web/tasks · high confidence

Chat example app added with iOS/Android/Desktop support

A new Chat example application has been added to the examples directory, demonstrating how to set up interop between SwiftUI and Compose. The example supports running on Android, iOS, desktop, and in a browser, and includes a README with setup instructions and run configurations for various targets.

examples/chat · high confidence

Default iOS app configuration for Imageviewer example

The Imageviewer iOS example now includes a default configuration file (Config.xcconfig) that sets the bundle identifier to org.jetbrains.Imageviewer and the app name to My Memories, providing a baseline setup for building the application.

examples/imageviewer/iosApp/Configuration · high confidence

Demo app showcases comprehensive resource loading capabilities

The shared demo application now includes dedicated UI screens for Images, Strings, Fonts, and Files, demonstrating the full range of the Compose Resources library. Users can see examples of loading vector and bitmap drawables via painterResource and imageResource, accessing string resources including templates and plurals, applying variable fonts with dynamic weight adjustment, and reading raw file bytes or URIs directly from the resource bundle.

components/resources/demo/shared/src/commonMain/kotlin · high confidence

Desktop resource environment detection and caching API

The desktop implementation of the resources library now detects system environment details such as locale, script, region, theme (dark/light), and screen density to select appropriate resources. It also introduces a public API, \ResourceCaches.clearBlocking()\, allowing users to clear internal resource caches to release memory or reset resources that may have changed. Additionally, the desktop-specific resource reader handles reading resources via class loader, supporting full reads, partial reads with offset/size, and URI retrieval, while ensuring proper stream handling.

components/resources/library/src/desktopMain · high confidence

Desktop-specific UI and platform implementations for the Image Viewer example

The Image Viewer example now includes a complete desktop implementation, adding platform-specific behaviors for the gallery and viewer interfaces. Users on desktop will see scrollbars in the image gallery and list views, a zoom slider for image scaling, and tooltip support for UI elements. The application window is centered and sized relative to the screen, with keyboard navigation (arrow keys) supported for moving between images. Since desktop hardware cameras are not simulated, the camera feature uses a stub that selects a random image from the resources instead of capturing live video. Additionally, location visualization now renders a map view on desktop, and image filters (grayscale, pixelate, blur) are processed using Java AWT operations.

examples/imageviewer/shared/src/desktopMain/kotlin/example/imageviewer/view · high confidence

ImageViewer example gains Web platform support

The ImageViewer example now runs in web browsers via Kotlin/Wasm. This adds web-specific implementations for image handling (Skia-based bitmap conversion), image storage (in-memory), and UI components (scrollbars, zoom slider, camera stub). The web app includes an HTML entry point with a warning overlay for browsers lacking Wasm GC support, and configures the Compose viewport to load the application.

examples/imageviewer/shared/src/webMain, examples/imageviewer/webApp · high confidence

Initial implementation of the Compose for Web runtime and testing infrastructure

This change introduces the core runtime for rendering Compose UI in web browsers, including the \renderComposable\ entry points to mount compositions to DOM elements, an internal DOM applier for managing the virtual DOM tree, and a snapshot manager to handle state updates. It also adds a benchmark suite for measuring UI performance (such as adding and removing items) and a set of compiler integration tests to verify that composables are correctly handled across module boundaries.

(repo-wide) · high confidence

Initial release of the ImageViewer example application

The ImageViewer example is now available in the examples directory, providing a reference implementation of an image gallery with camera and map support built on Compose Multiplatform for desktop, web, Android, and iOS. This addition includes the full project structure, build scripts, and documentation to help users set up their development environment and run the application across supported platforms.

examples/imageviewer · high confidence

Initial support for rendering SVG elements in Compose Web

This change introduces a new experimental API for building SVG graphics within Compose Web applications. It adds a comprehensive set of composable functions for standard SVG elements (such as \Svg\, \Circle\, \Rect\, \Path\, \Text\, and \G\) and their corresponding attributes (including \fill\, \fillOpacity\, \viewBox\, and geometric properties like \cx\, \cy\, \r\). The implementation is marked with \@ExperimentalComposeWebSvgApi\ to indicate its preliminary status, and includes a full suite of tests to verify correct DOM generation for these new components.

html/svg · high confidence

Introduce Compose HTML EAP with SSR hydration and strict validation

The html area now includes an experimental Compose HTML EAP (Early Access Program) module that adds server-side rendering (SSR) with browser hydration support. This allows the initial HTML to be rendered on the server and adopted by the client, preserving DOM nodes and crossing state boundaries. The EAP also introduces a strict validation mode for hydration mismatches (text, attributes, styles, structure) which is opt-in by default (fast validation is the default) and can be enabled via the \COMPOSE\_HTML\_VALIDATE\_STRICTLY\ environment variable or by passing \validateStrictly = true\ to \hydrateComposable\. The EAP artifacts are published under the \org.jetbrains.compose.html.eap\ Maven group and are excluded from the default Gradle build, requiring \compose.html.eap.enabled=true\ to activate. Also in this area: 4 commits (0 fixes) modifying html.

html · medium confidence · unverified

Introduce WebExtension for Gradle plugin configuration

A new WebExtension class has been added to the Compose Gradle plugin, providing an ExtensionAware base class that serves as the foundation for configuring web-specific Compose settings within the build script.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/web · medium confidence

Introduce build infrastructure for the JetBrains Compose Gradle plugin

This change adds the foundational build tooling for the JetBrains Compose Gradle plugin within the \buildSrc\ directory. It introduces a centralized \BuildProperties\ object to manage plugin metadata (name, group, website, VCS) and resolve version strings for the Compose compiler, Material3, and deployment artifacts via environment variables or Gradle properties. Additionally, it provides several custom Gradle tasks and utilities: \CheckJarPackagesTask\ to verify that JAR contents match allowed package prefixes, \GenerateBuildConfig\ to dynamically generate Kotlin configuration objects, \SerializeClasspathTask\ to capture classpath information, and helper extensions for configuring Maven publications and the plugin portal. These components collectively establish the build-time configuration and validation mechanisms required for the plugin's development and publication.

gradle-plugins/buildSrc · high confidence

Introduce experimental SplitPane component with RTL support

Adds a new SplitPane component for Compose that allows users to divide the screen into resizable sections. The implementation includes a DSL-based API (SplitPaneDSL.kt) for defining panes and custom splitters, state management via SplitPaneState, and explicit support for Right-to-Left (RTL) layout directions, ensuring the drag handle moves correctly in mirrored layouts.

components/SplitPane/library/src/commonMain · high confidence

Introduce non-interactive preview RPC protocol for Compose Desktop

This change adds the \gradle-plugins/preview-rpc\ module, which implements a new remote procedure call (RPC) protocol (version 2) to enable non-interactive previews for Compose Desktop modules. It introduces the \PreviewManager\ and \PreviewHost\ components that communicate over local sockets, allowing the IDE to send frame requests and receive rendered images without requiring an interactive UI session. The implementation includes command serialization, error handling, and a listener interface for build and render events, providing the underlying communication layer for the preview feature.

gradle-plugins/preview-rpc · high confidence

Introduce server-side HTML string rendering and hydration support

The Compose HTML EAP core now includes APIs for rendering Compose UI to HTML strings and streaming output, enabling server-side rendering (SSR) and browser hydration. New functions like \composeHtmlToString\, \composeHtmlToStream\, \renderHydratedDocument\, and \HydrationRoot\ allow developers to generate static HTML payloads that can be hydrated on the client. The implementation uses a single-pass composer for efficiency, supports keyed rendering with storage pooling for thread-safe reuse, and includes strict validation modes (opt-in via \validateStrictly\ or the \COMPOSE\_HTML\_VALIDATE\_STRICTLY\ environment variable) to catch HTML errors early.

html/eap/core · high confidence

Introduce versioned Compose scene API abstraction for benchmarks

A new \BenchmarkComposeScene\ interface has been added to encapsulate version-specific details of the Compose internal scene API. This abstraction allows benchmark code to remain stable across different Compose versions by isolating changes to internal APIs like \CanvasLayersComposeScene\ or \ComposeScene.render\ within specific implementations, ensuring cross-version compatibility for benchmarking.

benchmarks/multiplatform/compose-scene-api · high confidence

Introduce web-specific resource loading, caching, and preloading APIs

The web resources library now includes platform-specific implementations for loading and caching resources using the Web Cache API, which provides an extra layer of caching independent of the browser's default HTTP cache. To support asynchronous resource loading on the web, a custom \Promise.await()\ utility and a \webYield()\ function are added to bridge Kotlin coroutines with JavaScript Promises. The library also introduces \preloadFont\, \preloadImageBitmap\, and \preloadImageVector\ composables, allowing developers to pre-load resources and access them via \State\ objects to avoid loading delays during rendering. Additionally, \configureWebResources\ is provided to customize resource path generation, and \awaitPendingResourceStateLoads\ enables waiting for all pending resource state updates to complete.

components/resources/library/src/webMain · high confidence

Introduces internal Gradle plugin utilities and IDE import task

The Compose Gradle plugin now includes a new \IdeaImportTask\ to handle IDE synchronization safely, ensuring that IDE import operations are fast and do not interfere with the build cache. Additionally, several internal helper files have been added: \constants.kt\ defines plugin IDs and task names, \projectExtensions.kt\ provides extension properties to access Kotlin and Compose project extensions, and \requiredDslProperty.kt\ offers a delegate for enforcing required DSL properties. These changes support better integration with IntelliJ IDEA and improve the internal structure of the plugin.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/internal · high confidence

JetIssues example view implementation for Android and Desktop

The JetIssues example now includes a shared view component (JetIssuesView.kt) for both Android and Desktop JVM targets. This component provides a responsive UI that switches between single-column and two-column layouts based on screen width, displaying a list of issues and their details using Material Design components like Scaffold, TopAppBar, and SelectionContainer.

examples/issues/common/src/jvmAndAndroidMain/kotlin/androidx/ui/examples/jetissues/view · high confidence

Multiplatform template now includes Gradle wrapper and IDE run configurations

The multiplatform template now ships with a self-contained Gradle wrapper (version 8.13) and standard IDE run configurations for Android and Desktop targets. This allows users to build and run the template immediately without manually installing Gradle or configuring run profiles in their IDE.

ci/templates/multiplatform-template · high confidence

Native macOS resource loading and environment detection

The macOS implementation of the Compose Resources library now includes platform-specific logic to detect system environment details (such as locale, theme, and display density) and to read resource files from disk. This enables the library to correctly resolve localized resources and access assets like images and strings in native macOS applications by querying system settings and locating files within the app bundle or source directories.

components/resources/library/src/macosMain · high confidence

New CI tool for deleting packages from Space Maven repository

Added a new Gradle-based utility in the \ci/delete-packages-from-space\ directory that enables users to delete specific packages from a JetBrains Space Maven repository. The tool requires JDK 9+ and uses a personal token with ReadRepository, WriteRepository, and ViewProject permissions. Users configure connection details and target package versions in \local.properties\, then use Gradle tasks to list projects, generate a list of packages to delete (supporting wildcards), and execute the deletion.

ci/delete-packages-from-space · high confidence

New Compose HTML tutorials and updated navigation structure

Added a comprehensive set of tutorials for the Compose HTML library, covering getting started, building UI with HTML/CSS DSL, handling events, controlled vs. uncontrolled inputs, styling via the Style DSL, using DOM effects, and unit testing with test-utils. The main tutorials README has been restructured to organize links by target (iOS/Android/Desktop, Desktop, Web/Wasm, General, and Libraries), with the HTML section now pointing to these new local guides. Additionally, the main Getting Started guide has been updated to redirect users to the Kotlin Multiplatform online wizard and official documentation, and a new comparison guide for native packaging tools (built-in vs. Conveyor) has been added.

tutorials · high confidence

New Compose Multiplatform benchmark suite with multi-target and script support

A new benchmarking project has been added to measure Compose Multiplatform performance across Desktop, Android, iOS, macOS, and Web (Kotlin/Wasm and Kotlin/JS). The suite includes specific benchmarks for animations, lazy layouts, text rendering, and visual effects, supporting multiple measurement modes such as simple frame times, VSync emulation, real-world VSync, and application startup timing. To facilitate usage, Kotlin scripts are provided to run benchmarks on all supported platforms, compare results between different Compose versions, and automatically detect performance regressions via binary search.

benchmarks/multiplatform · high confidence

New Compose Multiplatform in UIKit interop example

Added a new example project demonstrating how to integrate Compose Multiplatform views within a native iOS UIKit application. The sample includes a complete Xcode project structure with Swift source files, showing a tabbed interface that hosts both a Compose Multiplatform entry point and a native UIKit view controller, along with the necessary Gradle wrapper and build configuration to compile and embed the shared Kotlin framework.

examples/interop/ios-compose-in-uikit · high confidence

New Compose for Web examples and multiplatform template

Added a new multiplatform template under \ci/templates/multiplatform-template\ that provides a basic Compose app structure for Android and Desktop targets, including platform-specific \getPlatformName\ implementations. Additionally, introduced three new HTML/JS examples: \compose-bird\ (a Flappy Bird-style game using Compose for Web), \compose-in-js\ (demonstrating how to embed and control Compose compositions from vanilla JavaScript), and \with-react\ (showing bidirectional integration between Compose for Web and React components).

(repo-wide) · high confidence

New Compose for Web landing page example

The HTML landing page example now features a complete UI built with Compose for Web, including a responsive layout, styled cards, a code sample switcher with syntax highlighting, and dedicated sections for introduction, libraries, getting started, and community engagement.

examples/html/landing, landing · high confidence

New DSL for desktop application packaging and distribution

The Compose Desktop Gradle plugin introduces a new domain-specific language (DSL) for configuring native application distributions. This update adds support for platform-specific settings for macOS, Windows, and Linux, including options for file associations, bundle identifiers, and installation paths. It also introduces build types (such as 'release') that enable ProGuard integration for obfuscation and optimization, as well as Ahead-of-Time (AOT) compilation features like AppCDS to improve startup performance. Additionally, the plugin now supports macOS code signing and notarization via the \notarytool\, replacing the legacy ASC provider method.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/dsl · high confidence

New Gradle plugin for Compose Multiplatform resources

The Compose Multiplatform Gradle plugin now includes a dedicated module for managing resources across Android, iOS, and other targets. This introduces a new DSL for configuring resource directories, generating Kotlin accessors, and handling platform-specific packaging (such as copying resources to Android assets and syncing iOS frameworks). It supports multimodule projects with resource publication, respects source set hierarchies, and integrates with AGP and CocoaPods to ensure resources are correctly included in the final build artifacts.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources · high confidence

New Gradle tasks for native desktop packaging and runtime validation

The Compose Desktop Gradle plugin now includes a suite of new tasks in the \application\ package to handle native application distribution. \AbstractCheckNativeDistributionRuntime\ validates the JDK environment, enforcing a minimum Java 17 version and warning against Homebrew JDKs on macOS. \AbstractCreateDistributableTask\ orchestrates the build of the app image, while \AbstractJLinkTask\ and \AbstractJPackageTask\ manage the creation of the custom JRE and the final platform-specific package (e.g., DMG, EXE). macOS-specific packaging is handled by \AbstractNativeMacApplicationPackageAppDirTask\ and \AbstractNativeMacApplicationPackageDmgTask\, which configure \Info.plist\ and generate DMG images. Additional capabilities include \AbstractNotarizationTask\ for Apple notarization using \notarytool\, \AbstractProguardTask\ for code shrinking, \AbstractCreateAotArchiveTask\ for AppCDS/AOT support, and \AbstractSuggestModulesTask\ to help users configure runtime modules.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/tasks · high confidence

New Graphics 2D example app with interactive demos

The shared examples module now includes a new Graphics 2D application that serves as a hub for several interactive Compose Multiplatform demos. Users can launch and switch between six distinct examples: BouncingBalls (interactive physics simulation), FallingBalls (click-to-catch game), MineSweeper (classic puzzle with platform-specific right-click support), RotatingWords (animated typography), WaveEffectGrid (mouse-reactive visual grid), and a Happy New Year visual effect. The app provides a unified navigation interface using Material 3 components and handles platform-specific input behaviors, such as right-click detection for Minesweeper.

examples/graphics-2d/shared · high confidence

New Lazy Grid Image benchmark showcase with size measurement tools

A new benchmark project has been added to compare the performance and binary size of a LazyVerticalGrid image display across three implementations: a shared Kotlin Multiplatform Compose app, a native Android Jetpack Compose app, and a native iOS SwiftUI app. The showcase includes scripts to download test images and measure resulting binary sizes for various targets (Android APK, Desktop JAR/Installer, iOS Framework/App Bundle, Web Wasm/JS), allowing users to compare metrics such as size, startup time, and resource usage between the cross-platform and native solutions.

benchmarks/showcases · high confidence

New LazyGridImageView showcase with native Android support

A new benchmark and showcase application named LazyGridImageView has been added, demonstrating a lazy vertical grid of images using Coil's AsyncImage component. The common Compose module provides the shared UI logic, including an auto-scrolling feature, while the native Android app implementation loads images directly from local asset files rather than bundled resources. This addition includes the necessary Android project scaffolding, such as the AndroidManifest, MainActivity, and launcher icons, to run the demo on native Android devices.

benchmarks/showcases/LazyGridImageView/composeApp, benchmarks/showcases/LazyGridImageView/nativeAndroidApp · high confidence

New code generator for a common kotlinx-browser subset in Compose HTML

A new generator module has been added to produce a shared subset of the kotlinx-browser API for Compose HTML. This tool analyzes browser-specific declarations and maps them to common Kotlin types, handling type mappings, signature analysis, and dependency discovery to ensure consistent cross-target support.

generator · high confidence

New common kotlinx-browser subset generator for Compose HTML

A new KSP-based code generator has been added under \html/kotlinx-browser-common-subset/generator\ to create a shared, common subset of the kotlinx-browser API for Compose HTML. This tool indexes browser declarations, resolves their inheritance hierarchies, and emits a unified facade model that can be used across targets. It includes a selection policy to define which browser APIs to include, a coverage ledger to track which declarations are ported or skipped and why, and an API manifest to ensure every input declaration is explicitly accounted for (emitted or excluded). This generator serves as the foundation for providing a consistent browser API surface in Compose HTML projects.

(repo-wide) · high confidence

New iOS chat example project structure

The chat example now includes a dedicated Xcode project (iosApp.xcodeproj) for iOS development. This project is configured to build a Swift application that integrates with the shared Kotlin codebase via a Gradle task, automatically embedding and signing the Apple framework during the build process. It includes specific Swift files for bridging Compose views to SwiftUI, such as KotlinToSwiftHelper and ComposeInsideSwiftUIScreen, allowing users to run and test the chat functionality directly on iOS devices or simulators.

examples/chat/iosApp/iosApp.xcodeproj · high confidence

New iOS interop entry point for embedding SwiftUI in Compose

The shared iOS module now includes a dedicated entry point function that creates a Compose UI hosting a SwiftUI view controller. This function uses ComposeUIViewController to build a layout containing a text label and a UIKitViewController wrapper around the provided SwiftUI controller, allowing users to integrate existing SwiftUI components directly within a Compose Multiplatform screen on iOS.

examples/interop/ios-swiftui-in-compose/shared · high confidence

New multiplatform benchmark suite with configurable modes and JSON reporting

The multiplatform benchmarks module now includes a comprehensive set of new benchmark scenarios (AnimatedVisibility, CanvasDrawing, ComplexLazyList, LazyGrid, TextLayout, etc.) and a unified configuration system (Config.kt) that supports multiple execution modes: SIMPLE, VSYNC\_EMULATION, REAL, and STARTUP. Users can now configure benchmark parameters such as frame count, warmup count, and empty screen delay via command-line arguments, and results can be saved to JSON or CSV files. The suite also introduces startup time measurement capabilities and aligns reporting for the 'real' mode with other modes, providing more detailed performance insights including CPU/GPU frame times and missed frame statistics.

benchmarks/multiplatform/benchmarks/src/commonMain · high confidence

New publishing library for Maven Central uploads and artifact management

The \ci/build-helpers/publishing\ module has been introduced as a reusable library to handle publishing workflows. It includes tasks to download artifacts from the internal Space repository with retry logic, discover modules via the Space API, and prepare artifacts for release by fixing POM metadata (filling in project URLs, licenses, and SCM details) and generating missing source/javadoc stubs. The library also implements the upload process to the new Maven Central Portal API using Ktor, including bundle creation, authentication, and status polling, while managing signing and checksum generation.

ci/build-helpers/publishing · high confidence

New release engineering and changelog tooling

This update introduces a suite of new scripts and configuration files in the tools directory to streamline the release process. A new changelog system includes a Kotlin script (changelog.main.kts) that parses GitHub PR release notes to generate CHANGELOG.md entries, supported by a PR\_FORMAT.md template defining required sections (e.g., Highlights, Fixes) and a GitHub Action to validate PR descriptions. Additionally, new shell scripts (replaceVersionInExamples.sh, replaceVersionInLibs.sh) automate the updating of Compose and Kotlin versions across example projects, CI configurations, and published components, while a new script (upload\_package\_from\_prebuilts.sh) enables uploading prebuilt packages to the Maven repository.

tools · high confidence

New validation scripts and documentation for Compose examples

The examples directory now includes a README listing available samples (Imageviewer, Codeviewer, Chat, Graphics2D, Nav Cupcake, Issues tracker, and HTML samples) and a set of shell scripts to validate their buildability. The scripts cover desktop packaging (validateExamples.sh), Android debug builds (validateExamplesAndroid.sh), iOS linking (validateExamplesIos.sh), and JS/Wasm builds (validateExamplesWithJs.sh). These scripts allow specifying Compose and Kotlin versions via command-line arguments to ensure examples compile against specific dev builds.

examples · high confidence

Stable Compose Multiplatform Resources API

The Compose Multiplatform resources library has been stabilized, introducing a unified API for loading and managing application resources across all supported platforms. This update adds comprehensive support for font resources (including font variation settings), plural string resources with locale-aware quantity rules, and string arrays. Image handling is expanded to support Bitmap, Vector (XML), and SVG drawables, with automatic density-based selection and downscaling logic that mirrors Android's resource resolution behavior. The library now exposes a \ResourceEnvironment\ that tracks language, script, region, theme, and density qualifiers to ensure correct resource selection. Internal caching mechanisms have been refactored to use a dedicated dispatcher and a blocking \ResourceLock\ to prevent deadlocks on the UI thread, and a public API is provided to clear internal resource caches when needed.

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources · high confidence

Stable Compose Resources API with multi-platform support

The Compose Resources library is now stable, removing experimental markers from its public API. This update introduces comprehensive support for loading fonts, images (including SVG and XML Vector Drawables on non-Android platforms), and plural strings across all targets, including Web and Wasm. It adds new APIs for preloading resources, clearing caches, and configuring Android contexts for previews, while ensuring consistent resource selection logic and density-based scaling across platforms. Also in this area: Support for multiple system locales in resource resolution; CodeViewer example migrated to Kotlin Toolchain; Configure Karma to serve Kotlin/JS and Kotlin/Wasm assets for testing; Resources library API dumps added for Android, Desktop, and Klib targets; iOS demo app updated to use modern Swift entry point; and 2 more.

components · high confidence

Support for XML Vector Drawables in the resources library

The resources library now parses Android XML Vector Drawables into Compose ImageVector objects. This new capability allows developers to use standard Android vector drawable XML files directly as resources, with the parser handling path data, groups, transformations, colors, and gradient brushes.

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources/vector · high confidence

Support for plural string resources

The resources library now supports plural string resources, allowing applications to display text that correctly adapts to the grammatical number of a quantity in the user's locale. This change introduces the internal infrastructure required for pluralization, including CLDR-based plural rule lists, plural category definitions, and a rule evaluation engine that selects the appropriate plural form based on the language and region qualifiers.

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources/plural · high confidence

Support for synchronous resource loading in blocking contexts

The resources library now provides platform-specific implementations for blocking resource access, enabling synchronous reading of resources during Compose composition. New files in the blockingMain source set implement \runResourceBlocking\ to execute resource blocks on the current thread without checking for thread interruption, allowing resources to be read safely even if the composition thread is interrupted. Additionally, \ResourceCaches\ is configured to use \Dispatchers.Unconfined\ for async cache operations, and \awaitPendingResourceStateLoads\ is implemented as a no-op for this context, ensuring that resource state can be resolved immediately without suspension.

components/resources/library/src/blockingMain · high confidence

iOS image filter implementation added

The iOS-specific implementation for image filters (grayscale, pixel, and blur) has been added to the ImageViewer example. This new file provides the platform-specific logic required to apply these visual effects on iOS devices using Skia, ensuring the feature works correctly across all supported platforms.

examples/imageviewer/shared/src/iosMain/kotlin/example/imageviewer/filter · high confidence

iOS image storage now persists and retrieves images via file-based storage

The iOS example application now implements a concrete file-based storage mechanism for images. It saves camera-captured images as JPEG files (including resized full-size and thumbnail versions) and metadata as JSON files within the app's document directory. The storage layer automatically loads existing images on startup, supports saving, deleting, and rewriting image data, and provides methods to retrieve image data for sharing, replacing any previous in-memory or placeholder storage approach.

examples/imageviewer/shared/src/iosMain/kotlin/example/imageviewer/storage · high confidence

iOS implementation for the ImageViewer example

The ImageViewer example now includes native iOS support, allowing users to run the application on iOS devices. This change introduces platform-specific components including the main view controller, image bitmap handling via Skia, and iOS-specific storage and sharing mechanisms using UIKit's UIActivityViewController.

examples/imageviewer/shared/src/iosMain/kotlin/example/imageviewer · high confidence

iOS platform-specific view implementations for the Image Viewer example

The Image Viewer example now includes native iOS implementations for several UI components, enabling full functionality on iOS devices. This adds a \GalleryScreen\ using \LazyVerticalGrid\, a \LocationVisualizer\ that embeds a native MapKit view via UIKit interop, and a \PlatformCamera\ implementation that handles camera access, orientation tracking, and photo capture using AVFoundation. Additionally, \ScrollableColumn\ delegates to \TouchScrollableColumn\, while \Tooltip\ and \ZoomControllerView\ are implemented as no-ops, reflecting iOS-specific UI behaviors where these controls are either unnecessary or handled differently.

examples/imageviewer/shared/src/iosMain/kotlin/example/imageviewer/view · high confidence

iOS resource environment detection and reading implementation

The iOS implementation for the Compose Resources library is now available, introducing \ResourceEnvironment\ to detect system locale (language, script, region), UI theme (dark/light), and screen density, alongside \ResourceReader\ to load resource files from the app bundle or XCFrameworks. This enables the resources library to function on iOS by providing the necessary platform-specific hooks for resolving resources based on user preferences and device characteristics.

components/resources/library/src/iosMain · high confidence

Behavioural changes

1 commit (0 fixes) modifying ci, ci/templates/gradle-jdk11-test

A change to existing behaviour in ci, ci/templates/gradle-jdk11-test — 1 commit, 6 files: “Added Gradle JDK 11 test template (\#5791)” (refs \#5791).

ci/templates/gradle-jdk11-test · medium confidence · unverified

2 commits (0 fixes) modifying compiler-plugin

A change to existing behaviour in compiler-plugin — 2 commits, 3 files: “Simplify Compose HTML EAP lowering (\#5777)”; “Support dynamic table content in Compose HTML EAP lowering (\#5778)” (refs \#5777, \#5778).

compiler-plugin · medium confidence · unverified

2 commits (0 fixes) modifying html/eap/compiler-plugin/gradle-plugin

A change to existing behaviour in html/eap/compiler-plugin/gradle-plugin — 2 commits, 3 files: “refactor compose-html-lowering plugin publication (\#5775)”; “Add compiler lowering for Compose HTML EAP SSR (\#5769)” (refs \#5775, \#5769).

html/eap/compiler-plugin/gradle-plugin · medium confidence · unverified

4 commits (1 fix) modifying html/eap/compiler-plugin

A change to existing behaviour in html/eap/compiler-plugin — 4 commits (1 fix), 8 files: “Simplify Compose HTML EAP lowering (\#5777)”; “Omit default namespace arguments in Compose HTML EAP lowering (\#5780)”; “Support dynamic table content in Compose HTML EAP lowering (\#5778)”; and 1 more (refs \#5777, \#5780, \#5778, \#5779).

html/eap/compiler-plugin · medium confidence · unverified

4 commits (2 fixes) modifying components/resources/library/src/jvmAndAndroidMain, components/resources/library/src/nativeMain/kotlin/org/jetbrains/compose/resources

A change to existing behaviour in components/resources/library/src/jvmAndAndroidMain, components/resources/library/src/nativeMain/kotlin/org/jetbrains/compose/resources — 4 commits (2 fixs), 8 files: “Replace suspend Mutex with blocking ResourceLock in AsyncCache to fix deadlock (\#5691)”; “Support bitmap/vector images, strings, fonts and raw resource loading”; “Revert "Rename components library modules. (\#3991)"”; and 1 more (refs \#5691, \#3991, \#5677).

components/resources/library/src/jvmAndAndroidMain, components/resources/library/src/nativeMain/kotlin/org/jetbrains/compose/resources · medium confidence · unverified

Add Graphics2D web example using ComposeViewport

The graphics-2d web example now launches via ComposeViewport, replacing the previous initialization method. This change updates the entry point to use the modern Compose for Web API, ensuring the application renders correctly within the specified DOM element ('composeApp') on WebAssembly-ready browsers.

examples/graphics-2d/jsApp · high confidence

Add ProGuard rules and update desktop entry point for the Issues example

The desktop Issues example now includes a ProGuard configuration file (compose-desktop.pro) to handle warnings and preserve classes for dependencies like OkHttp, Okio, and PrettyTime, ensuring a successful release build. Additionally, the main entry point (Main.kt) has been updated to use the modern Compose Desktop API (Window, WindowState, application) and explicitly terminates the Apollo Client process on exit to prevent background thread issues.

examples/issues/desktop · high confidence

Added JavaScript and WASM-JS benchmark entry points

The benchmark suite now includes specific entry points for JavaScript and WebAssembly-JS targets. For the JS target, a simple main function delegates to the browser benchmark runner. For the WASM-JS target, the implementation adds support for running benchmarks in the D8 environment (via a custom launch function returning a Promise) as well as in the browser, allowing the Jetstream3 benchmarks to run independently and handle environment-specific constraints like the lack of XML parsing in D8.

benchmarks/multiplatform/benchmarks/src/jsMain, benchmarks/multiplatform/benchmarks/src/wasmJsMain · high confidence

Android demo app updates platform-specific resource handling and SVG support

The Android demo module now includes a platform-specific text resource and a stubbed SVG showcase component that explicitly notes Android's lack of native SVG resource support, while non-Android targets retain full SVG rendering capabilities via the sailing.svg drawable. Additionally, the main Android entry point and preview composables have been added to demonstrate resource usage within the demo application.

components/resources/demo/shared/src/androidMain · high confidence

Automated Selenium driver installation and standardized Karma test configuration

The build system now automatically downloads and installs Chrome and Gecko (Firefox) WebDriver binaries for the current operating system and architecture, exposing Gradle tasks to install them and configuring the webdriver system properties so that browser-based tests run without manual driver setup. Additionally, Karma test execution is standardized to use headless Chrome and Firefox, with configuration directories automatically selected based on whether the target platform is WebAssembly or another JavaScript platform.

html/buildSrc · high confidence

Build helpers now use Gradle 8.13

The \ci/build-helpers\ module has been updated to use Gradle 8.13, replacing the previous version. This change ensures that build operations within this helper module leverage the features and stability of the newer Gradle release.

ci/build-helpers · high confidence

Build infrastructure updates for plural resources and artifact publishing

The build system now supports plural string resources by introducing a new Gradle task that generates Kotlin files from Unicode CLDR data, enabling proper quantity-based string handling. Additionally, artifact publishing has been refined: a new utility function ensures Maven publication metadata is configured after evaluation to work around an Android publication artifact ID issue, and artifact IDs are now standardized to use the '-android' suffix instead of '-androidRelease' for Android builds.

components/buildSrc · high confidence

Chat example updated to use ComposeViewport for web rendering

The chat web example now uses ComposeViewport to render the Compose UI within the browser, replacing the previous initialization method. This change updates the entry point to wait for WebAssembly readiness and mounts the UI into the 'composeApp' div, ensuring the application correctly integrates with the modern Compose Multiplatform web rendering pipeline.

examples/chat/jsApp · high confidence

CodeViewer example migrated to Kotlin Toolchain

The CodeViewer example now uses the Kotlin Toolchain instead of the previous Gradle-based build system. This migration replaces the Gradle wrapper and IDE run configurations with a new \kotlin\ CLI wrapper and \module.yaml\ files for each platform (Android, Desktop, iOS, Web, and Shared). The build process is now managed via the Kotlin CLI, which provisions its own distribution, and includes a helper script to build the example with specific Compose and Kotlin versions.

(repo-wide) · high confidence

Compose Gradle plugin enforces Kotlin 2.2.0 and new compiler plugin

The Compose Gradle plugin now requires Kotlin Gradle Plugin 2.2.0 or higher and mandates the use of the new \org.jetbrains.kotlin.plugin.compose\ compiler plugin. Projects using older Kotlin versions or the legacy compiler configuration will receive a build error. Additionally, the plugin introduces a runtime dependency compatibility check that warns if Compose Multiplatform libraries or Skiko versions do not match the plugin version, and adds Swift compatibility linking for iOS targets on macOS.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose · high confidence

Default ProGuard rules and macOS entitlements for desktop packaging

The Compose Gradle plugin now ships with default ProGuard configuration rules (default-compose-desktop-rules.pro) and macOS code-signing entitlements (default-entitlements.plist) to improve the reliability of release builds. The new ProGuard rules preserve necessary Kotlin, Skia, Coroutines, Material3, and kotlinx.serialization classes and suppress known warnings, preventing runtime crashes and serialization errors when obfuscation is enabled. The included macOS entitlements enable JIT execution and unsigned executable memory, which are required for the application to run correctly on macOS.

gradle-plugins/compose/src/main/resources · high confidence

Deprecation of JetBrains Compose Preview APIs in favor of AndroidX

The \Preview\, \PreviewParameter\, and \PreviewParameterProvider\ annotations and interfaces in the \org.jetbrains.compose.ui.tooling.preview\ package are now deprecated. Developers should migrate to the corresponding classes from \androidx.compose.ui.tooling.preview\ (specifically \org.jetbrains.compose.ui:ui-tooling-preview\). On Android, \PreviewParameterProvider\ is now a typealias to the AndroidX implementation, while on non-Android platforms it remains a stub interface. This change aligns the preview tooling with the standard AndroidX Compose tooling ecosystem.

components/ui-tooling-preview/library · high confidence

Desktop SplitPane layout and drag handling implementation

The desktop-specific implementation for the SplitPane component is now provided, introducing custom layout logic and interactive drag handling. The layout engine correctly calculates and enforces minimum size constraints for both panes, ensuring the splitter and handles remain within valid bounds during resizing. Additionally, the drag gesture handler respects the current layout direction (LTR/RTL), allowing users to resize the split panes accurately regardless of text direction.

components/SplitPane/library/src/desktopMain · high confidence

Desktop benchmarks now support GPU-accelerated rendering and server-side result collection

The desktop benchmark runner has been updated to support GPU-accelerated graphics on Windows via DirectX, enabling more realistic performance testing for graphics-intensive workloads. Additionally, a new Ktor-based server mode allows benchmark results to be sent from browser-based clients and saved to disk, providing a centralized way to collect metrics across different platforms.

benchmarks/multiplatform/benchmarks/src/desktopMain · high confidence

Desktop image storage now uses unique IDs for image retrieval

The DesktopImageStorage implementation has been updated to store and retrieve images using a unique identifier (picture.id) rather than the PictureData.Camera object itself. This change ensures that images are correctly associated with their specific IDs in the largeImages and thumbnails maps, preventing potential lookup failures or incorrect associations when multiple images are present. Additionally, platform-specific utilities for image bitmap conversion and UUID generation have been added to support this ID-based storage mechanism on the desktop platform.

examples/imageviewer/shared/src/desktopMain/kotlin/example/imageviewer · high confidence

Enforce explicit opt-in for experimental Compose targets

The Gradle plugin now validates that experimental targets (such as macOS ARM64) are explicitly enabled via a property in gradle.properties before they can be used. If a project attempts to build for an experimental target without setting the corresponding flag, the build will fail with a clear error message instructing the user to add the required property, preventing accidental usage of unstable features.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental · high confidence

HTML samples now use Gradle 8.13 and include IDE run configurations

The HTML-based sample projects (compose-bird, compose-in-js, landing) have been updated to use Gradle 8.13 via the wrapper, ensuring consistent build environments. Additionally, IDE run configurations have been added for each sample to simplify launching the browser-based applications directly from the IDE.

examples/html · high confidence

Image Viewer example refactored for Compose Multiplatform compatibility

The Image Viewer example has been restructured to support Compose Multiplatform, introducing a shared common module that uses expect/actual patterns for platform-specific operations like image conversion and camera access. The app now utilizes Compose Navigation 3 for screen transitions and Compose Resources for localized strings, while replacing external Material Icons with custom implementations to resolve iOS compatibility issues. Additionally, a new theming system with light and dark palettes and a robust zoom/pan state manager have been added to improve the user experience across devices.

examples/imageviewer/shared/src/commonMain/kotlin · high confidence

Improved Skiko runtime handling and test configuration validation for Compose for Web

The Gradle plugin now automatically unpacks the Skiko Web runtime into the build directory and correctly integrates it into the final web application distribution, ensuring the runtime is available for both Kotlin/JS and Kotlin/Wasm targets without duplication. Additionally, a new validation task checks that Compose UI browser tests are properly configured with an executable binary and webpack bundling; if this setup is missing, the build fails early with a clear error message explaining how to fix the configuration, rather than allowing tests to fail silently or confusingly later.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/web/internal · high confidence

Introduces internal data model for publishing modules

A new internal data class, ModuleToUpload, has been added to the publishing build helpers. This class structures module metadata (groupId, artifactId, version) and the local directory path, providing a helper to list files and generate a coordinate string. This change supports the internal mechanics of the publishing pipeline rather than exposing new user-facing features.

publishing · medium confidence

Migrate desktop image viewer to Compose

The desktop image viewer example has been updated to use Jetpack Compose for its UI. The application entry point now initializes a Compose application window, and the main view is implemented via the new ImageViewerDesktop component. Additionally, ProGuard rules have been added to ensure Ktor and related dependencies are preserved during release builds.

examples/imageviewer/desktopApp · high confidence

New internal utility library for Gradle plugin operations

The Compose Gradle plugin now includes a new set of internal utility files (diagnosticUtils, fileUtils, gradleUtils, osUtils, providerUtils, stringUtils, taskUtils) in the internal utils package. These utilities provide helper functions for handling file system operations, logging, OS/architecture detection, property resolution, and task registration, which will be used by the plugin to improve error messages, simplify resource management, and support project isolation.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/internal/utils · high confidence

Redesigned chat example with new UI and state management

The shared chat example has been completely redesigned to feature a modern UI with a scaffold layout, custom chat bubble shapes (including directional triangles), and a new color palette. The underlying state management has been replaced with a custom coroutine-based store and reducer pattern, and the app now includes a simulated background chat that automatically posts messages from friends every five seconds. Platform-specific entry points have been updated to launch the new ChatAppWithScaffold component.

examples/chat/shared · high confidence

Redesigned iOS chat example with SwiftUI integration

The iOS chat example has been modernized to use SwiftUI, replacing the previous implementation. The app now features a tabbed interface with a 'Group Chat' tab that embeds the Compose-based chat logic via a UIViewControllerRepresentable wrapper, and a 'Settings' tab. A native SwiftUI text input layer overlays the Compose view, allowing users to type messages that are sent to the shared Kotlin logic. The UI includes a custom send button, keyboard dismissal on tap, and specific color theming applied to the accent and background.

examples/chat/iosApp/iosApp · high confidence

Refactored Compose Desktop packaging into modular internal components

The internal implementation of the Compose Desktop Gradle plugin has been restructured into a set of dedicated classes to improve maintainability and support new packaging features. This change introduces \ComposeProjectProperties\ to centralize configuration flags (such as verbose logging, macOS signing, notarization, and Hot Reload settings) and \ExternalToolRunner\ to standardize the execution of external tools like \codesign\ and \jpackage\ with improved logging and error reporting. A new \InfoPlistBuilder\ allows for more flexible customization of macOS application metadata, while \MacSigner\ and \MacSigningHelper\ encapsulate the logic for code signing and entitlement handling. Additionally, \JvmApplicationData\ and \JvmApplicationInternal\ now separate the public DSL configuration from the internal state, and \JvmTasks\ provides a unified interface for registering packaging tasks. These changes underpin the plugin's ability to support advanced features like ProGuard, AppCDS, and native resource bundling.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/internal · high confidence

Refactored desktop packaging tasks and introduced ProGuard integration

The desktop packaging Gradle tasks have been refactored to support new packaging capabilities, specifically the ability to create uber JARs and integrate ProGuard for code shrinking and obfuscation. This change introduces \AbstractJarsFlattenTask\ to merge input JARs into a single artifact (required to handle ProGuard output correctly) and \AbstractUnpackDefaultComposeApplicationResourcesTask\ to extract default resources, including new default ProGuard rules and macOS entitlements. The base \AbstractComposeDesktopTask\ has been updated to use the modern \FileSystemOperations\ API instead of internal Gradle APIs, and all affected tasks are marked with \@DisableCachingByDefault\ to prevent incorrect caching of these dynamic resource and packaging operations.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/tasks · high confidence

Refactored macOS code-signing and file handling for desktop packaging

The desktop packaging plugin now uses a new internal file-processing architecture to handle macOS code-signing requirements more robustly. Specifically, it introduces logic to sign \.jnilib\ files (which the JDK does not sign automatically) and correctly handles \.dylib\ files by unsigning them when using JDK 17 to prevent conflicts with the JDK's own signing process, while leaving them alone for JDK 18+. This change also adds utilities for content hashing and deterministic JAR transformation to ensure reproducible builds.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/internal/files · high confidence

Restructured HTML core API with new attribute and event scopes

The HTML core library has been refactored to introduce a new, structured API for handling element attributes and events. This change adds dedicated scopes such as \InputAttrsScope\, \SelectAttrsScope\, and \TextAreaAttrsScope\ to provide type-safe, element-specific methods for values, checked states, and input events. It also introduces \AttrsScopeBuilder\ and \EventsListenerScopeBuilder\ to replace older builder types, alongside new experimental API markers (\ExperimentalComposeWebApi\, \ExperimentalComposeWebStyleApi\) and a comprehensive set of predefined attribute values (e.g., \InputType\, \FormMethod\) to improve developer experience and consistency.

html/core · high confidence

Skia-backed resource rendering and caching for images, fonts, and SVGs

The resources library now uses Skia primitives to render and cache image, font, and SVG resources on non-Android targets. Image resources are decoded via Skia with consistent downscaling when the source density exceeds the target density. SVGs are parsed into a Skia SVGDOM and rendered through a new SvgPainter that caches drawing results in an ImageBitmap to improve performance. Fonts are loaded and cached using Skia-backed APIs, with support for font variation settings and a bundled default font on web to prevent missing glyphs during async loading. A new internal DrawCache class manages bitmap-based drawing caching to reuse rendered content across frames.

components/resources/library/src/skikoMain · high confidence

Skiko implementation registered before scene creation in benchmarks

The benchmark implementation for the Skiko platform now explicitly registers the Skiko Compose implementation via \registerSkikoComposeImplementation()\ before instantiating the \BenchmarkComposeScene\. This ensures the underlying rendering infrastructure is correctly initialized prior to creating the scene, addressing potential initialization order issues in the benchmark harness.

benchmarks/multiplatform/compose-scene-impl-3 · high confidence

Stable Android resource API with context management and font variations

The Android resources library is now stable, introducing \AndroidContextProvider\ to automatically manage the Android context for resource reading and a new \setResourceReaderAndroidContext\ function to manually configure the context when automatic initialization fails (e.g., in previews or non-standard environments). Font resources now support \FontVariation.Settings\ for variable fonts, and image resources are downsampled if the source density exceeds the target density. The resource reader also supports reading resources from instrumented test contexts and provides URI access to assets.

components/resources/library/src/androidMain/kotlin · high confidence

Unified desktop configuration via DesktopExtension

The Compose Desktop plugin now exposes a single \DesktopExtension\ that consolidates application configuration. Users can configure both JVM-based and native desktop applications through dedicated \application\ and \nativeApplication\ blocks within this extension, streamlining the setup process for desktop targets.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop · high confidence

Updated Android example apps to use the new project structure

The Android example applications (Chat, Code Viewer, Graphics 2D, and Nav Cupcake) have been restructured to align with the new Gradle and Android Gradle Plugin setup. This includes adding standard Android manifest files, MainActivity implementations using Jetpack Compose, and necessary resource files such as app icons, strings, and themes. The Nav Cupcake example also introduces a shared Kotlin Multiplatform module containing the core application logic, UI screens, and view models, demonstrating the updated multiplatform architecture.

(repo-wide) · high confidence

Validation for macOS signing, notarization, and native package versions

The Gradle plugin now validates macOS signing and notarization configuration, requiring explicit Apple ID, password, and team ID for notarization, and enforcing correct bundle ID format, signing identity, and keychain paths for signing. It also validates native distributable package versions against platform-specific rules (Debian, RPM, Windows, macOS) and requires a build version for macOS packages, providing clear error messages and DSL property hints when validation fails.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/internal/validation · high confidence

Web demo now uses ComposeViewport and preloads fonts

The web demo application has been updated to use the ComposeViewport API for rendering and explicitly preloads font resources (Workbench, FontAwesome, and Noto Color Emoji) before the UI initializes. This ensures that custom fonts are available immediately, replacing the previous loading mechanism with a more robust preloading strategy that waits for font availability before displaying the main content.

components/resources/demo/shared/src/webMain · high confidence

iOS Image Viewer app project structure updated

The iOS app project for the Image Viewer example has been restructured to use a standard Xcode project configuration. The project now explicitly references \ContentView.swift\ and \iOSApp.swift\ as source files, includes asset catalogs for app icons and previews, and utilizes a \Config.xcconfig\ file for build settings. A build phase has been added to invoke Gradle for compiling and embedding the shared Kotlin framework, ensuring the native iOS app correctly integrates with the shared codebase.

examples/imageviewer/iosApp/iosApp.xcodeproj · high confidence

macOS benchmark runner now uses native AppKit window for real and startup modes

The macOS benchmark entry point has been updated to launch a native 1920x1080 AppKit window when running in 'real' or 'startup' modes, utilizing the display's maximum frames per second for rendering. In other modes, benchmarks continue to run in a headless context without a visible window, ensuring that performance measurements reflect actual UI rendering conditions on macOS.

benchmarks/multiplatform/benchmarks/src/macosMain · high confidence

Test coverage

1 commit adding/updating tests in html/eap/plugin-test-harness, plugin-test-harness; 2 commits adding/updating tests in gradle-plugins/compose/src/test/test-projects/misc/jsNoExecutableTests; 4 commits adding/updating tests in html/eap/compiler-plugin/tests; Add integration test projects and iOS manual test app; Add test cases for anonymous objects and local classes in Compose; Add value class composable test cases; Added AOT test project for AppCDS and AOT support; Added Compose integration test infrastructure for validating compiler behavior; Added JS multiplatform test project for Gradle plugin validation; Added JVM application integration test for Compose; Added JVM test fixture for MPP integration tests; Added ProGuard integration test for Compose Desktop; Added ProGuard integration tests for Compose Desktop packaging; Added Skiko WASM test project for Compose; Added composable-test-cases project to validate JetBrains Compose compiler behavior; Added comprehensive tests for the Compose Resources library; Added desktop resource loading tests; Added integration tests for Compose Gradle plugin features; Added integration tests for JVM Kotlin DSL application; Added test cases for Composable lambdas, null returns, and SAM conversion; Added test cases for Compose compiler inheritance and generic type handling; Added test cases for Compose stability inference; Added test coverage for composable expect/actual value getters; Added test for Skiko runtime with test-scoped dependency; Added test for new Android target; Added test project for Android app with Compose resources; Added test project for Android target with Compose resources; Added test project for CLI module dependency clash; Added test project for Compose runtime library compatibility checks; Added test project for JS multiplatform compilation; Added test project for JVM Compose Desktop preview; Added test project for JVM-only Compose resource generation; Added test project for Java logging module; Added test project for bundled KotlinPoet integration; Added test project for common resources API; Added test project for empty app resources; Added test project for macOS code signing with non-ASCII developer IDs; Added test project for macOS native Compose resources; Added test project for macOS packaging options; Added test project for multi-target Compose resource handling; Added test project for old Compose plugin compatibility; Added test project for validating argument handling with spaces; Added test project for verifying resource packaging; Added test project to verify Skiko library path unpacking; Added test projects for Compose Hot Reload and non-JVM application scenarios; Added test projects to verify default JVM argument handling for Compose Swing globals; Added test setup for Kotlin/JS Skiko runtime initialization; Added tests for Compose UI test resource support; Added tests for Compose resources in XCFrameworks; Added tests for KMP Compose resource publication across platforms; Added tests for empty resource directory handling; Added tests for font resource caching and variation font settings; Added tests for huge resource collection and accessor generation; Added tests for resource loading thread behavior and interruption handling; Added tests for the stable Compose Resources API; Added unit test for ImageViewer gallery style toggle; Added unit tests for Compose Gradle plugin internals; Added web application test fixtures for Kotlin/JS and Kotlin/Wasm; Added web-specific tests for Compose Resources; Configured JUnit 5 test execution for Compose Gradle plugin; New test infrastructure utilities for Compose Gradle plugin integration tests; Test expectations for Compose resource accessors and collectors; Updated expected test outputs for Compose resource generation with content hashes; Updated expected test outputs for JVM-only Compose resources.

Dependencies

Add Gradle wrapper for version 9.5.0

The Image Viewer example now includes a Gradle wrapper configuration that pins the build tool to version 9.5.0, ensuring consistent builds across environments without requiring a pre-installed Gradle.

examples/imageviewer/gradle · high confidence

Benchmark infrastructure updated to Kotlin 2.4.20 and Compose 1.12.1

The benchmark projects have been upgraded to use Kotlin 2.4.20 and Compose Multiplatform 1.12.1, with the Android Gradle Plugin raised to 9.1.1. The multiplatform benchmark suite now targets Android (minSdk 24), iOS (arm64/simulator), macOS (arm64), Wasm JS, and JS. To maintain compatibility across Compose versions, the build configuration dynamically selects the appropriate scene implementation module based on the resolved Compose version, supporting baseline APIs as well as newer FrameRecomposer and Skiko graphics registration patterns.

(dependencies) · high confidence

Graphics2D example now uses Gradle 9.5.0

The Graphics2D example project has been updated to use Gradle 9.5.0 as its build tool version. This change ensures the example uses the latest Gradle wrapper distribution, which may include performance improvements and bug fixes compared to previous versions.

examples/graphics-2d/gradle · high confidence

Updated Gradle wrapper to version 9.5.0

The Gradle wrapper for the chat example has been updated to use Gradle 9.5.0. This ensures that builds for this project will consistently use the specified Gradle distribution, improving build reproducibility and potentially leveraging new features or performance improvements in the Gradle build tool.

examples/chat/gradle, examples/issues/gradle, gradle-plugins/gradle · high confidence

iOS interop examples updated to Gradle 9.5.0

The iOS interop sample projects (ios-compose-in-swiftui, ios-swiftui-in-compose, and ios-uikit-in-compose) now use Gradle 9.5.0 as their build wrapper version. This ensures consistent build tooling across these examples and aligns them with the latest Gradle distribution.

examples/interop/ios-compose-in-swiftui/gradle, examples/interop/ios-swiftui-in-compose/gradle, examples/interop/ios-uikit-in-compose/gradle · high confidence

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

How this codebase got here

Score

  • CAI 56 → 62 (+5.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 79 → 78 (-0.5)
  • Architecture 83 → 84 (+0.8)
  • Maturity 69 → 74 (+5.1)
  • Readiness 43 → 53 (+9.6)
  • Security 62 → 59 (-2.9)
  • Accessibility 64 → 77 (+13.6)
  • Performance 80 → 94 (+14.3)

Resolved (68)

  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/StyleScope.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/StyleSheet.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/StyleSheet.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/transitions.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/InputElements.kt)
  • Duplicated block (10 lines × 2) (html/eap/examples/hydration-islands/src/jvmMain/kotlin/Server.kt)
  • Duplicated block (10–13 lines × 3) (examples/graphics-2d/shared/src/desktopMain/kotlin/visualeffects/PointerEvent.desktop.kt)
  • Duplicated block (11 lines × 2) (components/resources/library/src/iosMain/kotlin/org/jetbrains/compose/resources/ResourceEnvironment.ios.kt)
  • Duplicated block (11 lines × 2) (examples/codeviewer/androidApp/assets/data/EditorView.kt)
  • Duplicated block (11 lines × 2) (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/ComposeResourcesGeneration.kt)
  • Duplicated block (11 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/attributes/builders/InternalControlledInputUtils.kt)
  • Duplicated block (11 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/InputElements.kt)
  • Duplicated block (11 lines × 4) (components/resources/library/src/webMain/kotlin/org/jetbrains/compose/resources/ResourceState.web.kt)
  • Duplicated block (13 lines × 2) (examples/chat/iosApp/iosApp/ContentView.swift)
  • Duplicated block (13 lines × 2) (examples/codeviewer/shared/src@jvm/org/jetbrains/codeviewer/platform/Scrollbar.kt)
  • Duplicated block (13 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/RadioGroup.kt)
  • Duplicated block (13 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/RadioGroup.kt)
  • Duplicated block (13 lines × 3) (examples/codeviewer/androidApp/assets/data/EditorView.kt)
  • Duplicated block (14 lines × 2) (examples/imageviewer/shared/src/desktopMain/kotlin/example/imageviewer/view/ScrollableColumn.desktop.kt)
  • …and 48 more

New (531)

  • ConstantEvaluator.foldExpression (cognitive 20) (html/eap/compiler-plugin/src/main/kotlin/org/jetbrains/compose/html/compiler/lowering/ConstantEvaluator.kt)
  • ConstantEvaluator.foldExpression (cyclomatic 16) (html/eap/compiler-plugin/src/main/kotlin/org/jetbrains/compose/html/compiler/lowering/ConstantEvaluator.kt)
  • Critical CVE: [GHSA redacted] (examples/imageviewer/kotlin-js-store/yarn.lock)
  • Critical CVE: [GHSA redacted] (examples/nav_cupcake/kotlin-js-store/yarn.lock)
  • Critical CVE: [GHSA redacted] (examples/imageviewer/kotlin-js-store/yarn.lock)
  • Critical CVE: [GHSA redacted] (examples/nav_cupcake/kotlin-js-store/yarn.lock)
  • Critical CVE: [GHSA redacted] (examples/imageviewer/kotlin-js-store/yarn.lock)
  • Critical CVE: [GHSA redacted] (examples/nav_cupcake/kotlin-js-store/yarn.lock)
  • Dependency hygiene PARTLY measured — Gradle build resolved part of the dependency graph, currency reported but not scored
  • Duplicated block (10 lines × 2) (examples/imageviewer/shared/src/desktopMain/kotlin/example/imageviewer/view/PlatformCamera.desktop.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/StyleScope.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/StyleSheet.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/StyleSheet.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/transitions.kt)
  • Duplicated block (10 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/InputElements.kt)
  • Duplicated block (10 lines × 2) (html/eap/examples/hydration-islands/src/jvmMain/kotlin/Server.kt)
  • Duplicated block (10–13 lines × 3) (examples/graphics-2d/shared/src/desktopMain/kotlin/visualeffects/PointerEvent.desktop.kt)
  • Duplicated block (11 lines × 2) (ci/templates/desktop-template/src/main/kotlin/main.kt)
  • Duplicated block (11 lines × 2) (components/resources/library/src/iosMain/kotlin/org/jetbrains/compose/resources/ResourceEnvironment.ios.kt)
  • Duplicated block (11 lines × 2) (examples/codeviewer/androidApp/assets/data/EditorView.kt)
  • …and 511 more

Changes since last survey

  • 18 commits — 15 feature/other, 3 fixes

By area

  • html/eap — 9 commits
  • gradle-plugins/compose — 3 commits
  • benchmarks/multiplatform — 2 commits
  • (root) — 1 commit
  • ci/docker — 1 commit
  • ci/templates — 1 commit
  • gradle-plugins/gradle — 1 commit

Notable commits

  • fix: Fix Compose HTML EAP constant folding for Kotlin 2.5 (#5779)
  • fix: Fix gradle test run (#5776)
  • fix: Fix root certificate issue (#5789)
  • change: Add Compose HTML compiler plugin test harness (#5773)
  • change: Add benchmarks for Compose HTML EAP (#5781)
  • change: Add compiler lowering for Compose HTML EAP SSR (#5769)
  • change: Add golden IR tests for Compose HTML EAP compiler lowering (#5774)
  • change: Add missing Blob / Response polyfills (#5785)
  • change: Added Gradle JDK 11 test template (#5791)
  • change: Benchmarks: pass -Xwasm-use-new-exception-proposal to Wasm linkTask (#5787)
  • change: Bump hot reload version to 1.3.0-rc01 (#5782)
  • change: Changelog for 1.13.0-beta02 (#5786)
  • change: Compose Docker - reject eMudhra certificates (#5784)
  • change: Don't fail JS tests when an executable binary is not declared (#5772)
  • change: Omit default namespace arguments in Compose HTML EAP lowering (#5780)
  • change: Simplify Compose HTML EAP lowering (#5777)
  • change: Support dynamic table content in Compose HTML EAP lowering (#5778)
  • change: refactor compose-html-lowering plugin publication (#5775)

Architecture

  • Containers 0 added · 0 removed · contexts 16 added · 13 removed · edges 6 added · 5 removed

Added bounded contexts (16)

  • benchmarks/desktop
  • benchmarks/multiplatform/benchmarks
  • components/AnimatedImage/demo
  • components/SplitPane/library
  • components/resources/library
  • compose/integrations/composable-test-cases/testcases/constructors/lib
  • compose/integrations/composable-test-cases/testcases/stability/lib
  • compose/integrations/composable-test-cases/testcases/valueClass/lib
  • examples/chat/shared
  • examples/graphics-2d/shared
  • examples/imageviewer/shared
  • examples/nav_cupcake/shared
  • html/eap/benchmarks
  • compiler-plugin
  • components
  • plugin-test-harness

Removed bounded contexts (13)

  • benchmarks/desktop
  • benchmarks/multiplatform/benchmarks
  • checker
  • components/AnimatedImage/demo
  • components/SplitPane/library
  • components/resources/library
  • compose/integrations/composable-test-cases/testcases/constructors/lib
  • compose/integrations/composable-test-cases/testcases/stability/lib
  • compose/integrations/composable-test-cases/testcases/valueClass/lib
  • examples/chat/shared
  • examples/graphics-2d/shared
  • examples/imageviewer/shared
  • examples/nav_cupcake/shared

Added dependency edges (6)

  • examples/chat/shared → components/resources/library
  • examples/graphics-2d/shared → components/resources/library
  • examples/nav_cupcake/shared → components/resources/library (coupling)
  • compiler-plugin → kotlinx-browser-common-subset
  • compose → components/resources/library
  • compose-compiler-integration → compose/integrations/composable-test-cases/testcases/constructors/lib

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

  • compose → components/resources/library
  • compose-compiler-integration → compose/integrations/composable-test-cases/testcases/constructors/lib
  • examples/chat/shared → components/resources/library
  • examples/graphics-2d/shared → components/resources/library
  • examples/nav_cupcake/shared → components/resources/library (coupling)

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

Survey your own repository

JetBrains/compose-multiplatform 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 8431de3fdab6251ce5a0d7ab07303f5c85b13827 — 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.