Adaptive UI primitives for Compose Multiplatform.

AdaptiveKt is an alpha-stage Kotlin and Compose Multiplatform library for building responsive admin, productivity, and data-heavy interfaces from shared UI code. It focuses on the unglamorous but expensive parts of real app UI: layout breakpoints, dashboard shells, tables that become mobile cards, form sections, feedback states, navigation patterns, and reusable component defaults that look professional without requiring every call site to carry a wall of modifiers.

The project is published to Maven Central as 0.1.0-alpha01. It is usable for experimentation, demos, internal tools, and early integration feedback, but it is not a stable 1.0 API yet. APIs may change before beta/stable releases as the library hardens.

Compose Multiplatform makes it possible to share UI across platforms, but teams still need to solve responsive product UI patterns themselves. A simple admin screen often needs breakpoint rules, navigation mode changes, mobile-friendly data cards, clean action states, form layout decisions, empty/loading/error states, and consistent theme tokens.

AdaptiveKt exists to reduce that friction for Kotlin Multiplatform developers. Its direction is commonMain-first: shared primitives should work across Desktop/JVM, Android, Web/Wasm, and iOS where the underlying Compose Multiplatform tooling supports them.

This is not a replacement for Material, nor a claim to be a complete enterprise design system. AdaptiveKt is a focused toolkit for adaptive app patterns that can complement a product's own brand and component layer.

The repository also contains a docs-site and admin demo used to exercise the library visually. Those demo modules are not Maven artifacts.

AdaptiveKt is available from Maven Central.

repositories {
    google()
    mavenCentral()
}

dependencies {
    implementation("io.github.nikog4.adaptivekt:adaptive-components:0.1.0-alpha01")
}

Use only the modules your app needs:

dependencies {
    implementation("io.github.nikog4.adaptivekt:adaptive-core:0.1.0-alpha01")
    implementation("io.github.nikog4.adaptivekt:adaptive-components:0.1.0-alpha01")
    implementation("io.github.nikog4.adaptivekt:adaptive-layout:0.1.0-alpha01")
    implementation("io.github.nikog4.adaptivekt:adaptive-feedback:0.1.0-alpha01")
    implementation("io.github.nikog4.adaptivekt:adaptive-navigation:0.1.0-alpha01")
    implementation("io.github.nikog4.adaptivekt:adaptive-forms:0.1.0-alpha01")
    implementation("io.github.nikog4.adaptivekt:adaptive-data:0.1.0-alpha01")
}

import androidx.compose.runtime.Composable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.text.BasicText
import androidx.compose.ui.unit.dp
import io.github.adaptivekt.components.AdaptiveButton
import io.github.adaptivekt.components.AdaptiveCard
import io.github.adaptivekt.core.AdaptiveTheme
import io.github.adaptivekt.layout.AdaptiveGrid

import io.github.adaptivekt.core.AdaptiveApp

@Composable
fun DashboardSummary() {
    AdaptiveApp {
        AdaptiveGrid(columns = 12) {
            item(span = 6) {
                AdaptiveCard {
                    Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
                        BasicText("Revenue")
                        BasicText("\$42,800")
                        AdaptiveButton(
                            text = "View report",
                            onClick = { /* navigate */ },
                        )
                    }
                }
            }

            item(span = 6) {
                AdaptiveCard {
                    BasicText("Open invoices")
                    BasicText("18")
                }
            }
        }
    }
}

Select-style components expose controlled state:

var status by remember { mutableStateOf<String?>(null) }

AdaptiveSelect(
    options = listOf("Open", "Pending", "Closed"),
    selectedOption = status,
    onSelectedOptionChange = { status = it },
    optionLabel = { it },
    label = "Status",
    searchable = true,
    clearable = true,
)

AdaptiveKt is designed for Compose Multiplatform commonMain usage. Platform-specific screenshot tooling, Robot/AWT capture helpers, and demo image loading stay outside the library modules.

• Docs site & Demo Gallery: https://nikog4.github.io/AdaptiveKt/
• Component docs: docs/components
• Development setup: docs/development/setup.md
• Local publishing notes: docs/publishing/LOCAL_PUBLISHING.md
• Maven Central readiness notes: docs/publishing/MAVEN_CENTRAL_READINESS.md

• admin-demo: responsive admin dashboard demo for Desktop and Web/Wasm.
• ai-workspace-demo: complex SaaS/internal-tool showcase demonstrating advanced list/detail patterns, chat workspaces, prompt libraries, and form configurations.
• ecommerce-demo: complete frontend storefront demonstrating product grids, checkout, and layout primitives.
• docs-site: public Compose Multiplatform/Wasm documentation site and component catalog.

Demo Gallery / Live Site: You can view the interactive demo gallery at the AdaptiveKt GitHub Pages site.

How to run core validation:

.\gradlew.bat build
.\gradlew.bat :adaptive-core:jvmTest
.\gradlew.bat :adaptive-layout:jvmTest
.\gradlew.bat :adaptive-navigation:jvmTest

How to run ecommerce-demo:

.\gradlew.bat :examples:ecommerce-demo:desktopRun
.\gradlew.bat -p examples/ecommerce-demo wasmJsBrowserDevelopmentRun

How to run ai-workspace-demo:

.\gradlew.bat -p examples/ai-workspace-demo desktopRun
.\gradlew.bat -p examples/ai-workspace-demo wasmJsBrowserDevelopmentRun

How to prepare Pages locally: The GitHub Pages deployment merges Wasm distributions across modules into a single site-dist envelope. To build and stage this locally without committing the binary artifacts (which are git-ignored):

.\tools\prepare-pages-site.ps1

Current published version: 0.1.0-alpha01.

AdaptiveKt is alpha software. The current focus is to validate the API surface, improve documentation and examples, harden accessibility and keyboard/focus behavior, expand visual regression coverage, and gather feedback before stabilizing a beta API.

Kotlin Multiplatform adoption improves when developers can see credible paths for real user interfaces, not only small samples. AdaptiveKt targets a practical gap: shared responsive UI patterns for dashboards, internal tools, data workflows, and product admin screens.

The project can help:

• Kotlin Multiplatform developers prototype and ship shared UI faster.
• Compose Multiplatform adopters evaluate desktop, Android, Web/Wasm, and iOS UI from one codebase.
• Students, indie developers, and small teams learn commonMain-first UI architecture.
• Internal tool builders avoid rebuilding the same admin patterns from scratch.

Short-term alpha hardening:

• Stabilize core public APIs and document migration rules.
• Improve accessibility, keyboard navigation, focus, and pointer behavior.
• Expand visual regression and screenshot testing across Desktop and Web/Wasm.
• Add richer examples for admin, productivity, and ecommerce-style workflows.
• Validate iOS artifacts and demos on macOS.
• Continue theme/token work for light and dark modes.
• Build a contributor feedback loop through issues, templates, and documented governance.

See ROADMAP.md for the longer plan.

Contributions, bug reports, docs improvements, and API feedback are welcome. Start with CONTRIBUTING.md, and please keep changes commonMain-first unless a platform-specific boundary is intentional and documented.

See SECURITY.md for supported versions and private vulnerability reporting guidance.

AdaptiveKt follows a contributor code of conduct. See CODE_OF_CONDUCT.md.

AdaptiveKt is licensed under the Apache License 2.0. See LICENSE.