RAkII
1.2.2indexedLightweight runtime library and compiler plugin supports structured RAII for managing memory lifetime, reducing errors, resource leaks, and double-frees with error handling capabilities.
4
Stars
—
Used by
dependents
—
Health
/ 100
RAkII
RAkII (or Kotlin RAII) is a lightweight runtime library and compiler plugin which allows using structured RAII with support for error handling in Kotlin Multiplatform.
RAII is a concept commonly known from native languages such as C++ and Rust,
used for managing the lifetime of memory implicitly.
However, since Cleaners are not suitable for managing micro-allocations in
a granular manner in Kotlin, this library can be employed to reduce potential for
common errors, resource leaks and double-frees.
How to use it
Simply add the required repositories to your build configuration, apply the Gradle plugin and add a dependency on the runtime:
In your settings.gradle.kts:
pluginManagement {
repositories {
maven("https://central.sonatype.com/repository/maven-snapshots")
mavenCentral()
}
}
dependencyResolutionManagement {
repositories {
maven("https://central.sonatype.com/repository/maven-snapshots")
mavenCentral()
}
}
In your build.gradle.kts::
plugins {
id("dev.karmakrafts.rakii.rakii-gradle-plugin") version "<version>"
}
kotlin {
sourceSets {
commonMain {
dependencies {
implementation("dev.karmakrafts.rakii:rakii-runtime:<version>")
}
}
}
}
Note: It is recommended to use Gradle version catalogs which were omitted here for simplification.
Usage example
Performance implications
The RAkII compiler relies on the fact, that it can fall back to the runtime implementation
when no optimization is applicable for a certain case.
This means that certain usages of RAII constructs can employ a certain runtime overhead,
which may not always be desirable.
Take the following use cases of a deferring scope as an example:
As the above example illustrates as a fact:
If the DroppingScope instance is implicitly captured, compiler optimizations may not apply.
There is many more edge cases which are handled by the runtime due to complexity constraints in the compiler.