Asgard ships the structure and motion of a polished UI — a signature header, expressive navigation, connected segmented toggles, stat tiles, banners, charts, and tactile press animations — while reading all colors, typography, and shapes from the host app's MaterialTheme. The same component renders as "Thor" in one app and "Loki" in another; the library never imposes a palette or font.

Born from the Thor app's design system, extracted so every app — yours included — can share one component layer.

• 🎨 Theme-agnostic by design — every color, type, shape and motion value comes from your MaterialTheme. Drop it into any app and it looks like that app.
• 🧩 ~30 components + 5 charts — headers, navigation, inputs, stat cards, banners, settings rows, a pro-gate kit, progress rings, charts, and more.
• 🛠️ Deeply customizable — flat params for text truncation, typography, color, shape, padding, and accessibility on every component — with defaults that just work.
• 🪶 Featherweight — pure Compose, no icon pack and no third-party dependencies.
• 🌐 Kotlin Multiplatform — one artifact for Android and wasmJs.

trinadhthatakula.github.io/Asgard — browse every component and chart live, drag the interactive knobs, and flip light/dark and the seed color to watch each one inherit the theme. The gallery is itself built from Asgard, running in the browser via Compose Multiplatform (wasm).

Asgard is on Maven Central. Add the dependency — Gradle resolves the correct platform artifact automatically:

// build.gradle.kts
dependencies {
    implementation("com.trinadhthatakula:asgard:2.0.0")
}

Artifacts. Asgard is a Kotlin Multiplatform library published as three Maven Central coordinates. Depend on the umbrella asgard and Gradle resolves the right one per target — or depend on a single platform artifact directly if you only want one:

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("com.trinadhthatakula:asgard:2.0.0")
        }
    }
}

compileOnly("com.trinadhthatakula:asgard:2.0.0")

Upgrading from 1.x? See the Migration guide — 2.0 is mostly additive with a few small breaking changes (usually a 0–2 line change).

Wrap your app in any MaterialTheme (Asgard inherits it) and compose:

val tabs = listOf(
    AsgardNavItem(icon = Icons.Rounded.Apps, label = "Apps"),
    AsgardNavItem(icon = Icons.Rounded.AcUnit, label = "Freezer"),
)
var selected by remember { mutableIntStateOf(0) }

MaterialExpressiveTheme { // or your own MaterialTheme — Asgard follows it
    Scaffold(
        bottomBar = {
            AsgardNavigationBar(items = tabs, selectedIndex = selected, onSelect = { selected = it })
        },
    ) { padding ->
        Column(Modifier.padding(padding)) {
            AsgardHeader(
                title = "Apps",
                icon = Icons.Rounded.Dashboard,
                actions = {
                    ConnectedButtonGroup(
                        items = listOf(
                            ConnectedButtonGroupItem.Icon(Icons.Rounded.GridView, "Grid"),
                            ConnectedButtonGroupItem.Icon(Icons.AutoMirrored.Rounded.List, "List"),
                        ),
                        selectedIndex = 0,
                        onItemSelected = { /* … */ },
                    )
                },
            )

            AsgardStatCard(
                label = "Battery",
                value = "82",
                unit = "%",
                icon = Icons.Rounded.Bolt,
                modifier = Modifier.fillMaxWidth(),
            )
        }
    }
}

All icons are supplied by you as ImageVector — Asgard bundles no icon pack. The only built-in glyph is AsgardHeader's back arrow, a self-contained vector, so the library forces no material-icons artifact onto your app.

Every component reads color/type/shape from the ambient MaterialTheme, takes a modifier, and exposes flat customization params. Browse them all — live — in the gallery.

Structure & navigation

Inputs & actions

Data display

Feedback & states

Settings & monetization

Motion

A pure-Canvas charting set (no extra dependencies) in com.valhalla.asgard.charts, theme-agnostic like everything else:

AsgardLineChart(
    series = listOf(
        AsgardLineSeries(
            points = prices.mapIndexed { i, p -> AsgardChartPoint(i.toFloat(), p.value, p.date) },
            color = MaterialTheme.colorScheme.primary,
        ),
    ),
    yValueFormatter = { "₹${it.roundToInt()}" },
    modifier = Modifier.fillMaxWidth().height(220.dp),
)

Nothing is hardcoded. Asgard resolves color, typography, shape and motion from the host MaterialTheme, so it adopts your brand automatically:

MaterialExpressiveTheme(colorScheme = myBrandScheme, shapes = myShapes) {
    // every Asgard component now uses myBrandScheme + myShapes
}

• Shapes flow through AsgardDefaults, which reads MaterialTheme.shapes — override MaterialTheme.shapes and Asgard reshapes with your app. Any component also accepts a per-call shape.
• Customization params are flat and discoverable. Constrain text, restyle, recolor, repad, or add accessibility — all optional, all defaulted to sensible values:

AsgardActionItem(
    icon = Icons.Rounded.Notifications,
    label = "Notification settings",
    onClick = { /* … */ },
    labelMaxLines = 1,                                  // constrain text
    labelStyle = MaterialTheme.typography.titleSmall,   // restyle
    shape = RoundedCornerShape(12.dp),                  // reshape
)

The Expressive Material 3 theme gives the richest motion; any MaterialTheme works.

• Kotlin Multiplatform — Android (minSdk 28) + wasmJs, JDK 21
• Compose Multiplatform with Material 3. Asgard uses a few Material 3 Expressive APIs internally; wrapping your app in MaterialExpressiveTheme gives the richest motion, but any MaterialTheme works.

An integration skill for coding agents lives at .claude/skills/asgard-ui/SKILL.md — it teaches an agent how to add the dependency and use Asgard's components and charts correctly in a KMP or Android project.

Releases are automated: bump VERSION_NAME in gradle.properties on main and the Publish to Maven Central workflow publishes via the Vanniktech plugin, then tags + creates a GitHub Release. Credentials live in repository secrets. To publish manually on JDK 21:

JAVA_HOME=$(/usr/libexec/java_home -v 21) ./gradlew publishToMavenCentral

Local dry-run without a GPG key: ./gradlew publishToMavenLocal -PVERSION_NAME=2.0.1-SNAPSHOT.

Apache License 2.0.