kaluga

2.0.0-1742fc14cb-alpha.1212indexed

Offers modular tools for cross-platform mobile app development, including features like MVVM architecture, location services, permissions management, Bluetooth communication, and more, using coroutines and `Flow` for efficient design.

AndroidJSJVMNativeWasm·splendo/kaluga

397

Stars

—

Used by

dependents

Health

/ 100

kaluga logo

This project is named after the Kaluga, the world's biggest freshwater fish, which is found in the icy Amur river.

Kaluga's main goal is to provide access to common features used in cross-platform application development, separated into modules such as location, permissions, bluetooth etc.

To reach this goal it uses Kotlin, specifically Kotlin Multiplatform, recommended in combination with Compose Multiplatform. Supported targets differ per module depending on platform features. We aim to support Android, iOS/iPadOS, macOS, watchOS, tvOS, Javascript, and Javascript WebAssembly where applicable.

Where appropriate coroutines and Flow are used in the API. This enables developers to use cold streams for a modern and efficient design.

While Kaluga modules can be used individually, together they form a comprehensive approach to cross-platform development.

Short examples

With Kaluga it is possible to create cross-platform functionality in a few lines of code, that would normally take many lines of code even on just one platform.

Below are some examples, using a commonMain source-set:

Localization:

val locale = KalugaLocale.defaultLocale
val casing = "istanbul".upperCased(locale) // locale-aware, e.g. "İSTANBUL" in tr
if (locale.unitSystem == UnitSystem.IMPERIAL) i("this locale prefers imperial units")

DateTime:

val tomorrow = DefaultKalugaDate.now().apply { day += 1 }
val formatter = KalugaDateFormatter.dateFormat(DateFormatStyle.Medium)
i(formatter.format(tomorrow)) // e.g. "Jul 8, 2026"

Observing location:

val locationStateRepo = LocationStateRepoBuilder().create(Permissions.Location(background=false, precise=true))
locationStateRepo.location().collect { location ->
    // Handle location change
}

Scanning for nearby devices with Bluetooth LE:

// will auto request permissions and try to enable bluetooth
val client = BluetoothClientBuilder().createClient()
client.startScanning()    
try {
    client.devices().collect {
        i("discovered device: $it") // log found device
    }
} finally {
    client.stopScanning()
}

Scientific calculations:

val forceInNewton = 60(Kilogram) * 4(Meter per Second per Second)
val forceInPoundForce = forceInNewton.convert(PoundForce)
i("${CommonScientificValueFormatter.default.format(forceInNewton)} == ${CommonScientificValueFormatter.default.format(forceInPoundForce)}")

More examples

Kaluga contains an example project that is used to test the developed modules. A Javascript version of this example can be found on https://kaluga.splendo.com/example/

Using Kaluga

Kaluga is available on Maven Central. For example the Kaluga Alerts can be imported like this:

repositories {
    mavenCentral()
}
dependencies {
    implementation("com.splendo.kaluga.alerts:alerts:$kalugaVersion")
}

You can also use the SNAPSHOT version based on the latest in the develop branch:

repositories {
    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
}
dependencies {
    implementation("com.splendo.kaluga.alerts:alerts:$kalugaDevelopVersion-SNAPSHOT")
}

Available Modules

Modules are organized into feature groups; each group directory has its own README with more detail. The table below lists every published module, its artifact coordinate, and the platforms it supports.

Friends of kaluga

Of course not every possible functionality is provided by kaluga. However, this is often because other good multiplatform libraries that work nicely with kaluga already exist. These use similar patterns such as coroutines and Flow, and include the following:

Project	Usage
kotlin-firebase-sdk	wraps most of the Firebase SDK APIs

Kaluga also uses some multiplatform libraries itself, so our thanks to:

Project	Usage
Napier	powers the logging module
Koin	dependency injection

Developing Kaluga

see DEVELOP.

Related libraries

Surfaced from shared tags and platforms — no rankings paid for.

KSafe★ 301

ioannisaEffortlessly encrypts and persists data using hardware-backed security, offering one-code-path simplicity, seamless integration, and protection for sensitive information like OAuth tokens.Shared: kotlin-flow, kotlin-coroutines, compose

KScan★ 336

ismai117Enables easy barcode scanning in apps using Google’s MLKit on Android and Apple's AVFoundation on iOS, supporting QR and EAN-13 formats with simple integration.Shared: device, compose, apple

SimpleMVI★ 224

artttttLightweight MVI library enables structured state management with unidirectional data flow, type safety, coroutine support, and clear separation between UI and domain logic.Shared: kotlin-coroutines, architecture, apple

kilua★ 364

rjarosComposable web framework enabling modern web application development with declarative UI components, state management, server-side rendering, and support for WebAssembly and JavaScript targets.Shared: kotlin-flow, kotlin-coroutines, compose

konnection★ 170

TM-AppsLibrary emits network connection status, offers immediate connection state checks, IP info retrieval, and network state observation. Supports customizable instance creation and includes default IP resolvers.Shared: kotlin-flow, kotlin-coroutines, apple

EasyQRScan★ 147

kalinjulQR-Code and other 2D/3D code scanner for Compose Multiplatform. Offers basic permission handling, supports multiple code types, and includes a sample app for reference.Shared: device, compose, apple

val locale = KalugaLocale.defaultLocale val casing = "istanbul".upperCased(locale) // locale-aware, e.g. "İSTANBUL" in tr if (locale.unitSystem == UnitSystem.IMPERIAL) i("this locale prefers imperial units")

// will auto request permissions and try to enable bluetooth val client = BluetoothClientBuilder().createClient() client.startScanning() try { client.devices().collect { i("discovered device: $it") // log found device } } finally { client.stopScanning() }

val forceInNewton = 60(Kilogram) * 4(Meter per Second per Second) val forceInPoundForce = forceInNewton.convert(PoundForce) i("${CommonScientificValueFormatter.default.format(forceInNewton)} == ${CommonScientificValueFormatter.default.format(forceInPoundForce)}")