Compile-time Aspect-Oriented Programming for Kotlin Multiplatform.

AspectK is a Kotlin compiler plugin that injects advice into your functions at compile time, using the K2 IR transformation API. There is no runtime reflection and no proxy. Declare an @Aspect, mark its advice with @Before, @After or @Around, and the calls are compiled into every function that carries the target annotation.

[!WARNING] AspectK is in alpha. The API can change without notice between releases, and you may run into bugs. Pin the version you depend on and read the changelog before upgrading.

[!IMPORTANT] Use 0.4.2 or later. This is strongly recommended. It is the version validated on the DuckDuckGo Android browser.

// build.gradle.kts
plugins {
    id("io.github.mole-labs.aspectk") version "LATEST_VERSION"
}

For Kotlin Multiplatform:

plugins {
    kotlin("multiplatform")
    id("io.github.mole-labs.aspectk") version "LATEST_VERSION"
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.BINARY)
annotation class Logged

import io.github.molelabs.aspectk.runtime.Aspect
import io.github.molelabs.aspectk.runtime.Before
import io.github.molelabs.aspectk.runtime.JoinPoint

@Aspect
object LoggingAspect {
    @Before(target = [Logged::class])
    fun log(joinPoint: JoinPoint) {
        println("→ ${joinPoint.signature.methodName}(${joinPoint.args.joinToString()})")
    }
}

@Logged
fun processOrder(orderId: String, amount: Double) {
    // AspectK injects LoggingAspect.log() here at compile time
}

AspectK 0.4.2, resolved from Maven Central, was applied to DuckDuckGo for Android: an open-source browser with 50M+ downloads on Google Play and 4.8k stars on GitHub. The whole change is public at oungsi2000/Android (branch aspectk-trial).

AspectK is built with the help of AI tools, but it is not vibe-coded. The roles are split:

• A human designs the architecture and the tests. What the library does, how it is structured, which trade-offs it accepts and which cases the tests have to cover are decided by a maintainer, and recorded in pull requests: each merged PR states what changed and why.
• AI does the legwork. It reverse-engineers how Gradle and the Kotlin compiler plugin API behave, hunts for bugs, researches, and drafts code and documentation to that design.
• A human reviews every change and has to understand it before it is merged.
• Changes are verified by four test suites, all run in CI:
  • aspectk-core tests compile sources with the plugin and check the woven result
  • aspectk-core-tests (commonTest) run woven code on JVM, JS, Wasm and iOS
  • aspectk-plugin functionalTest drives real Gradle builds, including incremental ones
  • sample tests build a multi-module app against the working tree, on JVM, Android, JS and iOS

Advice is injected during IR transformation, before any platform-specific lowering, so AspectK sees functions the way you wrote them:

• Class member functions
• Top-level functions
• Extension functions
• suspend functions. Injection happens before coroutine lowering, so no continuation parameter shows up in args
• inline functions. The advice is part of the body, so it is inlined along with it
• Property getters and setters
• expect/actual functions across all platforms

JVM · Android · JS (IR) · WASM/JS · macOS (arm64, x64) · iOS (arm64, sim, x64) · Linux (arm64, x64) · Windows (x64) · watchOS · tvOS · Android Native

Full documentation: https://mole-labs.github.io/aspectk/

• Installation
• Quick Start
• Core Concepts
• API Reference

Copyright 2026 Mole Labs

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0