Compose Super Charts is a Kotlin Multiplatform charting library built with Compose. It keeps chart APIs readable, puts styling into configuration objects, and shares chart components across Android, iOS, and desktop targets.

The library is being prepared for release. The sample app is the quickest way to explore the available charts, compare behavior across platforms, and find useful areas to contribute.

• Android, iOS, and desktop JVM targets.
• Canvas-based chart rendering.
• Per-chart data and style configuration objects.
• Shared tooltip component with edge clamping, optional close button, and auto-dismiss timing.
• Tooltip anchor and overflow strategies for product-specific placement.
• Shared legends with top, bottom, and hidden positions.
• Legend alignment, padding, row/flow/column layout modes, row spacing, and single-series visibility controls.
• Optional legend item toggling for supported multi-series charts.
• Optional value labels and formatter callbacks where the chart supports them.
• Null-aware line and area rendering with configurable gap behavior.
• Separate y-axis, x-axis, tooltip, and accessibility formatters for line-style charts.
• Optional tick providers for generated axes when product screens need exact business-friendly tick values.
• Custom tooltip and legend renderer hooks for product-specific UI.
• Optional ChartScaffold and AnalyticsChartCard wrappers for chart headers, overlays, footers, summary values, and product-specific actions.
• Empty, loading, and error state helpers through ChartDisplayState and ChartStateView.
• Accessibility description helpers for chart semantics.
• Sample screens for every chart type, including controls for common configuration options.

compose-super-charts/
  compose-super-charts/   Core chart library module
  sample-app/             Shared Android/iOS sample app
  sample-desktop/         Desktop sample launcher
  iosApp/                 Xcode project for the iOS sample

Library code is grouped by responsibility:

components/atoms/         Small reusable UI pieces
components/molecules/     Shared chart pieces such as legends, tooltips, slots, cards, and state views
components/organisms/     Complete chart composables
models/                   Data and style configuration objects
utils/                    Accessibility, formatting, modifiers, and export helpers
domain/                   Chart math helpers

From the repository root:

./gradlew :compose-super-charts:compileDebugKotlinAndroid
./gradlew :sample-app:compileDebugKotlinAndroid
./gradlew :sample-app:compileKotlinDesktop

Run the desktop sample:

./gradlew :sample-desktop:run

Install the Android sample:

./gradlew :sample-app:installDebug

Open the iOS sample from iosApp/iosApp.xcodeproj after the Kotlin Multiplatform project has synced.

After the first Maven Central release is available, add:

dependencies {
    implementation("io.github.kotalsumit:compose-super-charts:1.1.1")
}

Until the Maven Central publication is live, add the module locally:

include(":compose-super-charts")

Then depend on it from your Compose module:

dependencies {
    implementation(project(":compose-super-charts"))
}

The library is configured for Maven Central publishing through the Central Portal.

Before publishing, create and verify the io.github.kotalsumit namespace in Maven Central, then add these GitHub Actions secrets:

MAVEN_CENTRAL_USERNAME
MAVEN_CENTRAL_PASSWORD
SIGNING_PASSWORD
GPG_KEY_CONTENTS_BASE64

The release workflow runs when a GitHub release is published. It uploads artifacts to Maven Central, where the deployment can be reviewed and released.

val points = listOf(
    ChartPointData(
        xLabel = "Mon",
        yValues = listOf(24f),
        highlightLabels = listOf(TooltipBubbleData("Sales", "24"))
    ),
    ChartPointData(
        xLabel = "Tue",
        yValues = listOf(42f),
        highlightLabels = listOf(TooltipBubbleData("Sales", "42"))
    ),
    ChartPointData(
        xLabel = "Wed",
        yValues = listOf(31f),
        highlightLabels = listOf(TooltipBubbleData("Sales", "31"))
    )
)

LineChart(
    modifier = Modifier
        .fillMaxWidth()
        .height(300.dp),
    points = points,
    maxY = 5,
    yAxisLabel = "Sales",
    legendLabels = listOf("Revenue"),
    config = ChartStyleConfig(
        lines = listOf(
            ChartLineConfig(
                lineStyle = SolidLine(color = Color(0xFF2563EB)),
                pointStyle = SolidPoint()
            )
        ),
        legendPosition = LegendPosition.BOTTOM,
        legendContentAlignment = LegendContentAlignment.START,
        legendContentPadding = PaddingValues(horizontal = 0.dp),
        legendLayoutMode = LegendLayoutMode.ROW,
        xAxisLabelRotation = -35f,
        tooltipAnchor = TooltipAnchor.POINT_TOP,
        tooltipOverflowStrategy = TooltipOverflowStrategy.SHIFT_INSIDE,
        nullPointBehavior = NullPointBehavior.BreakSegment,
        areaFillBehavior = AreaFillBehavior.CloseToBaselinePerSegment,
        yAxisTickFormatter = { value -> value.toInt().toString() },
        yAxisTickProvider = { _, _ -> listOf(30f, 20f, 10f) },
        tooltipValueFormatter = { value -> "${value.toInt()} units" },
        showTooltipCloseButton = true,
        tooltipAutoDismissMs = 2500
    )
)

For product UIs that need their own tooltip or legend presentation, pass tooltipContent, legendItemRenderer, or legendMarkerRenderer in ChartStyleConfig. These hooks are optional; the built-in tooltip and legend remain the default.

Use ChartScaffold when the chart needs local header, footer, or overlay content without creating another app-side wrapper. Use AnalyticsChartCard when a product screen wants a reusable card with a title, summary value, action slot, and chart content.

Use tick providers only when the default evenly spaced ticks are not enough. Formatters control labels; providers control the actual values shown on the axis.

Small, focused pull requests are easiest to review. Before opening one:

1. Run the relevant compile commands.
2. Test the changed chart in the sample app.
3. Include screenshots or a short recording for visual changes.
4. Mention Android, desktop, or iOS testing in the PR.
5. Keep public API changes intentional and easy to spot.

When adding a chart, follow the existing shape:

1. Add data models in models/.
2. Add a style config in models/.
3. Add the composable in components/organisms/.
4. Reuse TooltipBubble, UniversalLegend, ChartText, and ChartDivider when possible.
5. Add accessibility semantics through ChartAccessibility.
6. Add a sample screen with controls for the important options.
7. Update this README and the changelog.

• Keep tooltip behavior consistent near chart edges.
• Keep sample screens useful for manual testing.
• Improve accessibility coverage as interactions become richer.
• Add tests around chart math and configuration edge cases.
• Prepare publishing and release packaging.

Apache License 2.0. See LICENSE.