JetBrains/compose-multiplatform

This repository is the source code for Jetpack Compose Multiplatform, a framework for building native user interfaces across Android, iOS, Desktop, and Web using Kotlin. It provides the core UI libraries, a Gradle plugin for project configuration and packaging, and a comprehensive suite of examples demonstrating cross-platform capabilities and native interop. The system also includes extensive tooling for performance benchmarking, compiler validation, and CI/CD automation to support the development and distribution of multiplatform applications.

58 changes.

This period focused on significantly enhancing the Compose Gradle plugin's desktop packaging capabilities, introducing a new DSL for native distributions, ProGuard integration, and macOS code signing. Concurrently, the project expanded its example suite with new applications for issues tracking, image viewing, and code display, while adding a SplitPane component to the library.

85 changes.

This period focused on establishing the foundational infrastructure for Compose for Web, including the introduction of an experimental HTML runtime with server-side rendering and comprehensive integration tests. Simultaneously, the project significantly expanded its iOS ecosystem by stabilizing the Compose Resources library and adding extensive example projects demonstrating bidirectional integration between Compose and native iOS frameworks like SwiftUI and UIKit.

51 changes.

This period focused on establishing a comprehensive multiplatform benchmarking suite to measure performance across Android, iOS, Desktop, and Web targets, while simultaneously hardening the Compose Resources API through extensive test coverage and stability validation. Significant work was also dedicated to expanding web support via Kotlin/Wasm integration, automatic fallback mechanisms, and server-side rendering capabilities for Compose HTML.

The Android demo application for the Resources component has been added, providing a concrete example of how to use the library on Android. This includes the main activity entry point, the AndroidManifest configuration, and string resources, allowing users to run and inspect the demo locally.

components/resources/demo/androidApp · high confidence

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

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

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

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

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

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

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

The Compose Desktop Gradle plugin now includes a new internal configuration mechanism that automatically registers a \configureDesktopPreview\ task for both Kotlin Multiplatform (JVM targets) and standard Kotlin/JVM projects. This change enables users to run non-interactive previews by leveraging the \AbstractConfigureDesktopPreviewTask\, which correctly wires up the necessary JVM runtime files and Skiko runtime dependencies for the preview environment.

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

The components directory now includes the Gradle wrapper scripts (gradlew, gradlew.bat), a .gitignore file, and a README with usage instructions. A new test.sh script has been added to automate running tests across desktop, Android, iOS, and WebAssembly targets for the resources library, enabling local development and verification of the component's resource loading capabilities.

components · high confidence

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

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

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

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

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 toggle the move-enabled state of the splitters, adjust splitter positions using raw delta values, and set specific position percentages, providing a practical example of the component's API and behavior.

components/AnimatedImage/demo, components/SplitPane/demo · high confidence

The desktop Code Viewer example now includes a dedicated JVM entry point that launches a single-window application with a fixed 1280x768 resolution and a custom launcher icon loaded from resources. This change establishes the specific UI initialization logic for the desktop variant of the example.

examples/codeviewer/desktopApp · high confidence

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

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

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

A new iOS test application has been added to verify basic Compose Multiplatform functionality on iOS 13.0 and later. The app includes a shared Kotlin entry point that exercises text field interactions, native button integration via UIKitView, and dialog display, alongside the necessary iOS project configuration (Xcode project, assets, and launch screen) to support manual testing and TestFlight distribution.

compose/ios-manual-tests · high confidence

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

The ImageViewer example now includes a native iOS application layer, allowing users to run the example directly on iOS devices. This adds the necessary SwiftUI entry point (iOSApp.swift), a ContentView that hosts the shared Compose logic via a UIViewControllerRepresentable wrapper, and standard iOS asset configurations including the app icon, accent colors, and Info.plist with required camera and location usage descriptions.

examples/codeviewer/iosApp/iosApp, examples/imageviewer/iosApp/iosApp · high confidence

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

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

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

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

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

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

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

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

The Codeviewer application now includes a dedicated JVM implementation for file handling in the shared module. This change introduces a new \JvmFile\ component that manages file operations, such as reading lines and navigating file structures, specifically for the JVM platform. This ensures that the Codeviewer example functions correctly on JVM-based environments by providing the necessary platform-specific logic for file I/O.

examples/codeviewer/shared/src/jvmMain · high confidence

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

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

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

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

The repository now includes a new example project at examples/interop/ios-uikit-in-compose that demonstrates how to integrate UIKit views within a Compose Multiplatform application. The addition includes the necessary project scaffolding, such as the Gradle wrapper scripts (gradlew, gradlew.bat), a .gitignore file configured for iOS development artifacts, and a README explaining the usage of UIKitView in the shared iOS source.

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

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

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

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

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

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

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

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

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

The multiplatform benchmarking suite now includes an Android target, allowing performance measurements to be run on Android devices. This change introduces Android-specific implementations for benchmark saving, time measurement, and graphics context handling. Notably, Android benchmarks are restricted to 'REAL' mode (via Activity/BenchmarkRunner) as simulated modes like Simple and Vsync Emulation are not supported on this platform. The skiko-based implementation remains unchanged, continuing to support Simple and Vsync Emulation modes for non-Android targets.

(repo-wide) · high confidence

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

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

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

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

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

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

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

This change introduces the core runtime foundation for Compose for Web, including the \renderComposable\ entry points for mounting compositions to DOM elements, the internal \DomApplier\ for managing DOM tree updates, and the \GlobalSnapshotManager\ to handle snapshot state notifications on the JavaScript platform. It also adds the initial benchmarking suite (\benchmark-core\) with tests for DOM insertion and removal performance, and provides a template project (\compose-compiler-integration\) to demonstrate compiler integration.

html/benchmark-core, html/compose-compiler-integration/main-template, html/internal-html-core-runtime · high confidence

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

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

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.

html · high confidence

A new code-generation module has been added to produce a shared browser API facade for Compose HTML. The generator uses KSP to analyze browser-specific expect declarations, resolves a transitive closure of required classifiers, maps types to a common Kotlin model, and emits the resulting source files. It also produces coverage and API-manifest reports to track which declarations were ported or excluded, ensuring that every input declaration is explicitly accounted for.

html/kotlinx-browser-common-subset, html/kotlinx-browser-common-subset/generator, html/kotlinx-browser-common-subset/generator/verification · high confidence

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

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

Adds a new SplitPane component (HorizontalSplitPane and VerticalSplitPane) to the Compose Multiplatform library, allowing users to divide UI space into resizable sections. The component includes a DSL for configuring pane content and minimal sizes, a SplitPaneState for managing position and movement enablement, and a customizable splitter with handle alignment options. The API is marked as experimental.

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

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

The Compose HTML EAP core now includes APIs for rendering Compose UI trees directly to HTML strings without creating browser DOM nodes, enabling server-side rendering (SSR). This adds the \composeHtmlToString\ function for one-off or keyed reusable string rendering, and \renderHydratedDocument\ for generating complete HTML documents. To bridge the server-rendered output with the client, the new \HydrationRoot\ composable emits the initial application state in an inert script tag and marks the root element with hydration protocol attributes, allowing the browser to take over without full re-rendering. Strict HTML validation is available as an opt-in feature via the \COMPOSE\_HTML\_VALIDATE\_STRICTLY\ environment variable or the \validateStrictly\ parameter, and the \AttrsScope\ now supports \allowHydrationMismatch\ to tolerate specific client-server differences.

html/eap/core · high confidence

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

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

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

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

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

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

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

Added new example projects and CI templates demonstrating Compose for Web capabilities. This includes a multiplatform template with Android and Desktop targets, a 'Compose Bird' game example running in the browser, a 'Compose in JS' example showing how to integrate Compose into existing JavaScript applications, and a 'With React' example demonstrating bidirectional integration between Compose and React components.

(repo-wide) · high confidence

The HTML landing page example has been rewritten using the Compose for Web API, replacing the previous implementation. This update introduces a fully reactive UI built with Compose for Web components, including a new layout system, a code sample switcher with syntax highlighting via highlight.js, and a responsive design using CSS variables and media queries. The page now features a modern look with light and dark themes, interactive cards, and a footer with social links, demonstrating the capabilities of Compose for Web for building complex, reactive web interfaces.

examples/html/landing · high confidence

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

The Compose Multiplatform Gradle plugin now includes a dedicated resource management module that handles code generation, platform-specific asset bundling, and multimodule support. This implementation introduces tasks to generate typed resource accessors and a central Res class, supports BCP 47 locale qualifiers (including script codes), and manages Android asset registration with compatibility for AGP 8.10+ and AGP 9.0.0-alpha01. It also adds logic to sync resources to iOS/macOS app bundles and Xcode build directories, including checks for Xcode sandboxing constraints.

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

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

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

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

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

The ImageViewer desktop example now includes a MapView component that displays Earth tile maps via the OpenStreetMap API. This addition introduces a Compose-based map interface supporting pan, zoom, and click interactions, along with the underlying logic for tile calculation, coordinate conversion, and network handling. The implementation features parallel request limiting to respect OpenStreetMap's tile usage policies, a distinct downloader to avoid redundant network calls, and a disk cache for offline availability.

examples/imageviewer/mapview-desktop · high confidence

A new \AbstractConfigureDesktopPreviewTask\ has been introduced to handle desktop preview configuration. This task establishes a connection to the IDE to send preview settings, automatically manages the inclusion of the Skiko runtime JAR when necessary, and ensures compatibility with the Gradle configuration cache by disabling caching for this specific operation.

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

Added shell scripts to streamline local development workflows: \publishComponentsToMavenLocal\, \publishGradlePluginToMavenLocal\, and \publishHtmlLibraryToMavenLocal\ allow developers to publish specific Compose modules to the local Maven repository using a custom version; \skikoAospCommit\ and \skikoAospPush\ automate updating and pushing Skiko version changes in the AOSP repository, including platform-specific sed handling; \validateProjects.sh\ provides a way to verify that example projects compile against specific Compose and Kotlin versions.

compose/scripts · high confidence

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

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

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

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

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

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

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.

components/resources/library · high confidence

The Xcode project file for the iOS Codeviewer example has been added, establishing the build configuration for the native iOS app. This includes the main application entry point (iOSApp.swift), the primary user interface component (ContentView.swift), and asset catalogs. The project is configured to integrate with the shared Kotlin codebase via a build phase that executes a Gradle task to embed and sign the Apple framework, ensuring the native UI can access the shared logic.

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

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

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

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

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

The resources library now includes binary compatibility validator API dumps for the Android, Desktop, and Klib (iOS, JS, macOS, wasmJs) targets. These files formally document the public API surface, including resource types like \StringResource\, \DrawableResource\, and \FontResource\, as well as Compose integration functions such as \stringResource\, \imageResource\, and \vectorResource\. This change establishes the baseline for enforcing API stability across platforms and does not alter runtime behavior.

components/resources/library/api · high confidence

The Codeviewer example now includes Android-specific implementation files to support multiplatform development. These changes add an empty AndroidManifest, a Compose entry point, and platform-specific stubs for file handling, mouse cursor resizing, and scrollbars. On Android, scrollbar rendering and horizontal cursor resizing are currently no-ops, allowing the shared UI logic to compile and run while deferring native Android UI details.

examples/codeviewer/shared/src/androidMain · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This change introduces several new internal helper classes and utilities within the Compose Gradle plugin to support upcoming features and improve code organization. It adds a \Version\ class for semantic version parsing and comparison, a \ComposeCompilerArtifactProvider\ to handle compiler plugin artifact resolution (including custom plugin support), and an \IdeaImportTask\ with \@DisableCachingByDefault\ to safely handle IDE import operations. Additionally, it defines constants for Kotlin plugin IDs and provides project extension helpers to access Compose, Web, JVM, and JS extensions more cleanly.

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

The CodeViewer example now adapts to the system's appearance by supporting both light and dark themes. The shared UI layer detects the current system theme via \isSystemInDarkTheme\ and applies the corresponding \Theme\ configuration (light or dark) through a \CompositionLocal\. This includes distinct color palettes for backgrounds, surfaces, and code syntax highlighting, as well as platform-specific implementations for scrollbars and cursors to ensure the visual style is consistent across targets.

examples/codeviewer/shared/src/commonMain · high confidence

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

The experimental and example projects, including the Chat desktop application and the Codeviewer, have been relocated into a dedicated 'examples' directory. This change organizes the repository structure by moving platform-specific implementations (such as the JVM main entry point for Chat and the desktop-specific file and mouse handling for Codeviewer) and iOS configuration files into this new location, separating them from the core library code.

(repo-wide) · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

The iOS demo application now uses the modern @main entry point annotation in its Swift code, replacing the deprecated @UIApplicationMain. This change aligns the demo with current iOS development standards and ensures compatibility with newer Xcode versions.

components/resources/demo · high confidence

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

Add test cases for anonymous objects and local classes in Compose; 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 integration test projects for Compose compiler and KTX serialization; 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 JS Compose UI text rendering; 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 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 huge resource collection and accessor generation; 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 value class test cases for the Compose compiler; Added web application test fixtures for Kotlin/JS and Kotlin/Wasm; 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.

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

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

The Code Viewer example project has been updated to use Gradle 9.5.0 as its build tool version. This change updates the Gradle wrapper properties to download and use this specific version, ensuring consistent build environments for the example.

examples/codeviewer/gradle · high confidence

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

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

The Gradle wrapper configuration for the multiplatform benchmarks has been updated to use Gradle 9.3.1. This ensures that running benchmarks uses a consistent, modern build tool version, which may improve build performance and compatibility with newer Kotlin or Android Gradle Plugin features.

benchmarks/multiplatform/gradle, components/gradle · high confidence

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

• CAI 42 → 61 (+19.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 93 → 95 (+2.5)
• Architecture 96 → 77 (-18.5)
• Maturity 50 → 70 (+19.6)
• Readiness 26 → 58 (+32.7)
• Security 42 → 63 (+20.6)
• Accessibility 58 (new)

• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (html/kotlin-js-store/yarn.lock)
• Dimension evaluation failed
• Duplicated block (11 lines × 2) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/FileRes.kt)
• Duplicated block (11 lines × 2) (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/ComposeResourcesGeneration.kt)
• Duplicated block (12 lines × 4) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/StringRes.kt)
• Duplicated block (14 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/filter.kt)
• Duplicated block (18 lines × 2) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/ImagesRes.kt)
• Duplicated block (19 lines × 2) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/FileRes.kt)
• Duplicated block (19 lines × 2) (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/AndroidResources.kt)
• Duplicated block (19 lines × 3) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/ImagesRes.kt)
• Duplicated block (19 lines × 4) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/ImagesRes.kt)
• Duplicated block (21 lines × 2) (html/svg/src/jsMain/kotlin/org/jetbrains/compose/web/svg/svgAttrs.kt)
• Duplicated block (24 lines × 3) (components/resources/library/src/webMain/kotlin/org/jetbrains/compose/resources/ResourceState.web.kt)
• Duplicated block (27 lines × 3) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/FontRes.kt)
• Duplicated block (33 lines × 3) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/transform.kt)
• Duplicated block (37 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/box.kt)
• Duplicated block (37 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/grid.kt)
• Duplicated block (40 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/text.kt)
• Duplicated block (43 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/grid.kt)
• …and 85 more

• AbstractJPackageTask.makeArgs (cognitive 20) (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/tasks/AbstractJPackageTask.kt)
• AbstractJPackageTask.prepareWorkingDir (cognitive 17) (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/tasks/AbstractJPackageTask.kt)
• Change coupling: PlatformSettings.kt ↔ AbstractJPackageTask.kt (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/dsl/PlatformSettings.kt)
• Change coupling: PlatformSettings.kt ↔ configureJvmApplication.kt (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/dsl/PlatformSettings.kt)
• Change coupling: ResourceReader.macos.kt ↔ IosResources.kt (components/resources/library/src/macosMain/kotlin/org/jetbrains/compose/resources/ResourceReader.macos.kt)
• ClassTooLong: AbstractJPackageTask (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/tasks/AbstractJPackageTask.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• DownloadFromSpaceMavenRepoTask.downloadArtifactsFromComposeDev (cognitive 27) (ci/build-helpers/publishing/src/main/kotlin/org/jetbrains/compose/internal/publishing/DownloadFromSpaceTask.kt)
• Duplicated block (10 lines × 2) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/ImagesRes.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 × 4) (components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/StringRes.kt)
• Duplicated block (104 lines × 2) (html/core/src/jsMain/kotlin/org/jetbrains/compose/web/css/properties/box.kt)
• Duplicated block (10–13 lines × 3) (examples/graphics-2d/shared/src/desktopMain/kotlin/visualeffects/PointerEvent.desktop.kt)
• Duplicated block (11 lines × 2) (gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/ComposeResourcesGeneration.kt)
• …and 193 more

• 42 commits — 39 feature/other, 3 fixes

• gradle-plugins/compose — 10 commits
• components/resources — 9 commits
• html/eap — 8 commits
• (root) — 4 commits
• html/kotlinx-browser-common-subset — 3 commits
• benchmarks/multiplatform — 2 commits
• ci/templates — 2 commits
• gradle-plugins/gradle — 1 commit
• tools/changelog — 1 commit
• tools/replace_version_common.sh — 1 commit
• tutorials/Image_And_Icons_Manipulations — 1 commit

• fix: Fix Android targets with new Compose versions (#5719)
• fix: Fix a skiko runtime when a skiko dependency is added in a test source set only (#5701)
• fix: Replace suspend Mutex with blocking ResourceLock in AsyncCache to fix deadlock (#5691)
• change: Add API for awaiting asynchronous Compose resource loads (#5720)
• change: Add Compose Resources consumer R8 rule (#5667)
• change: Add HTML string rendering to commonized Compose HTML core (#5705)
• change: Add Kotlin/Wasm JS support to Compose HTML EAP (#5722)
• change: Add a common kotlinx-browser subset for Compose HTML (#5693)
• change: Add a fallback for deleted wasm API in Kotlin 2.5 (#5716)
• change: Add browser hydration to Compose HTML EAP (#5710)
• change: Add changelog for 1.13.0-alpha01 (#5704)
• change: Add common SVG declarations to kotlinx-browser common subset (#5712)
• change: Add common SVG support to Compose HTML EAP (#5715)
• change: Add commonized EAP version of Compose HTML core for JVM (#5703)
• change: Add foojay-resolver plugin to application/jvm project (#5714)
• change: Added changelog for 1.12.0 (#5692)
• change: Added changelog for 1.12.1 (#5725)
• change: Allow excluding libraries from the dependency compatibility check (#5694)
• change: Android. Raise minimum supported SDK to 24. Tests (#5698)
• change: Benchmarks: cleanup deprecations and update versions (#5729)
• …and 22 more

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

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.