Compose Multiplatform

The Compose Multiplatform benchmarks suite contains performance tests for various UI components and rendering scenarios across different platforms. Key benchmark categories include:

• Animations: AnimatedVisibility (toggling visibility of images) and VisualEffects (complex particle animations).
• Lazy Layouts: LazyGrid (various configurations including smooth scrolling and async tasks in items) and LazyList (complex implementations with pull-to-refresh).
• Rendering & Graphics: CanvasDrawing (massive amounts of graphic shapes), HeavyShader (complex GPU shaders), and TextLayout (heavy text layout/rendering).
• Component Stress Tests: MultipleComponents (comprehensive UI with layouts and animations) and TextLayout.

This test application is designed to verify that fundamental features of Compose Multiplatform are functioning correctly on iOS. It serves as a baseline for ensuring core Compose capabilities work as expected on the iOS platform.

Key Requirements & Details:

• Deployment Target: iOS 13.0
• Core Entry Point: The logic for the iOS implementation can be found in shared/src/iosMain/kotlin/main.ios.kt.

Compose Multiplatform is a declarative framework developed by JetBrains for sharing UI code across multiple platforms using Kotlin. It is built upon Jetpack Compose and leverages Kotlin Multiplatform (KMP) to enable code sharing between different operating systems.

Supported platforms for sharing UI include:

• iOS
• Android
• Desktop (Windows, macOS, and Linux)
• Web (currently in Beta)

Compose Multiplatform for Desktop provides specialized APIs for desktop-class user experiences. Key areas of focus include:

• Input & Interaction: Mouse events, hover states, keyboard support, and tab focus navigation.
• UI Components: Scrolling, scrollbars, tooltips, context menus, and menu/tray/notifications.
• Window Management: Top-level window management and building native distributions.
• Interoperability & Testing: Swing interoperability and UI testing.
• Navigation & Accessibility: Routing/navigation and accessibility support.

The examples/html directory contains several demonstration projects showcasing how Compose Multiplatform can be used in web environments. These samples cover different integration patterns, including standalone games, landing pages, and interoperability with existing web frameworks like React or vanilla JavaScript.

### Available Samples:
* [compose-bird](compose-bird) - A simple game about a bird
* [Landing page](landing) - A landing page built using Compose
* [Compose with React](with-react) - Using compose-in-react and react-in-compose
* [Composable in JS](compose-in-js) - Using HTML based Composables

The Compose Multiplatform ecosystem consists of several key parts:

• Core: The main development happens in the compose-multiplatform-core repository, where Jetpack Compose is adapted for iOS, Desktop, and Web targets.
• Gradle Plugin: Used to integrate Compose Multiplatform into your build process.
• IDEA Plugin: Provides IDE support within IntelliJ IDEA.
• Skiko: The low-level rendering and event handling layer.
• Examples: Reference implementations and usage patterns.

The Compose HTML library enables building reactive user interfaces for the web using Kotlin. It allows you to express state, behavior, and logic using Compose concepts while providing a declarative HTML/CSS API for full layout control.

Important Compatibility Note: The Compose HTML library does not currently support Kotlin/Wasm.

Compose Multiplatform relies on Skiko, a low-level library designed to hide platform complexity. It provides a unified interface for:

• Rendering (using Skia as the graphical API)
• Event handling
• Window management
• Other low-level platform features

In this project, there is a distinction between Compose HTML and Compose for Web:

• Compose HTML: Refers to the Compose-based library for targeting the web via JavaScript/DOM.
• Compose for Web: Now specifically refers to Compose based on WebAssembly (Wasm).

Each test case is a small, independent project located in the ./testcases directory. To ensure cross-module compilation is tested, every test case must consist of at least two modules:

1. ...-lib module: Contains the test dependencies.
2. ...-main module: Contains the actual tests that verify behavior.

Behavioral verification is performed by creating a simple text Composition and comparing its text dump against an expected string value. The text Composition API is provided by the common module.

@Test
fun testExample2() = runTest {
    val root = composeText {
        TextLeafNode("Leaf")
        TextContainerNode("node") {
            TextLeafNode("child1")
            TextLeafNode("child2")
            TextLeafNode("child3")
        }
    }

    assertEquals("root:{Leaf, node:{child1, child2, child3}}", root.dump())
}