LoKdroid is a Kotlin Multiplatform logging library with a shared core API for Android, desktop JVM, and iOS, plus Android-specific extensions for file and Logcat-oriented logging.

• Shared logging API: Use the same LoKdroid, log functions, and builder DSL from common code.
• Multiplatform targets: Core logging works on Android, desktop JVM, and iOS.
• Shared formatter DSL: FormatterBuilder is available from shared code and formats logs on all three platforms.
• Customizable formatting and tagging: Override formatter, logger, tag provider, and message builder factory.
• Best-effort caller resolution: Shared caller normalization skips internal LoKdroid wrapper frames on Android, desktop JVM, and iOS.
• Platform-native console behavior: Android uses Logcat; desktop JVM and iOS use formatted console output with emoji level markers.
• Android-specific extensions: File logging, Logcat-formatted files, and remote logging remain available on Android.
• Compose demo apps: The repository includes Android, desktop, and native iOS demo hosts backed by a shared Compose Multiplatform UI module.

View KDoc

The repository uses flat Gradle project paths while keeping grouped folders on disk:

LoKdroid/
├── library/
│   ├── core/       -> Gradle module :core
│   └── domain/     -> Gradle module :domain
└── demoApp/
    ├── androidApp/ -> Gradle module :androidApp
    ├── desktopApp/ -> Gradle module :desktopApp
    ├── sharedUI/   -> Gradle module :sharedUI
    └── iosApp/     -> native iOS Xcode host app, not part of the Gradle build

Notes:

• library/ and demoApp/ are directories for organization, not Gradle modules.
• :sharedUI contains the shared Compose Multiplatform screens used by the Android, desktop, and iOS demo hosts.
• demoApp/iosApp is a native Xcode application that imports the sharedUI framework and hosts Compose UI through MainViewController.

Add LoKdroid to your project:

repositories {
    mavenCentral()
}

Kotlin DSL

dependencies {
    implementation("io.github.nikolaykuts:lokdroid:0.1.2-alpha")
}

Groovy

dependencies {
    implementation 'io.github.nikolaykuts:lokdroid:0.1.2-alpha'
}

For a Kotlin Multiplatform project, put the dependency in commonMain when you need the shared API there. FormatterBuilder is part of the shared API and can be used from code that targets Android, desktop JVM, and iOS. Android-specific implementations such as FileLogger, ConsoleAndFileLogger, RemoteLogger, and FileFormat are available only from androidMain.

Initialize LoKdroid before logging starts:

LoKdroid.initialize()

• Android: run the androidApp application module from Android Studio.
• Desktop: run ./gradlew :desktopApp:run
• iOS: open demoApp/iosApp/iosApp.xcodeproj in Xcode and run the iosApp scheme.

The repository already contains a native iOS host app under demoApp/iosApp.

• The shared Kotlin UI is exposed from :sharedUI as the sharedUI framework.
• The Swift app initializes logging through MainViewControllerKt.initializeLoKdroid().
• The root Compose screen is embedded through MainViewControllerKt.MainViewController().

Minimal integration looks like this on the Swift side:

import SwiftUI
import sharedUI

@main
struct iosAppApp: App {
    init() {
        MainViewControllerKt.initializeLoKdroid()
    }

    var body: some Scene {
        WindowGroup {
            ComposeRootView()
        }
    }
}

logV(message = "some message")
logD(message = "some message")
logI(message = "some message")
logW(message = "some message")
logE(message = "some message")

val year: Int = currentDate.year
val month: Int = currentDate.monthValue
val dayOfWeek: java.time.DayOfWeek = currentDate.dayOfWeek

logI {
    "Date:"()
    "Year: $year"()
    "Month: $month"()
    "Day of the Week: $dayOfWeek"()
}

Inside the IMessageBuilder DSL, the string extension function accepts an optional Level. The default MessageBuilder uses that value to prepend an emoji marker for the corresponding line.

Shortcuts available inside the builder:

• V for Level.Verbose
• D for Level.Debug
• I for Level.Info
• W for Level.Warn
• E for Level.Error

logV {
    "multi log"()
    "some Error"(E)
    "some Info"(I)
    "some Debug"(D)
    "some Verbose"(V)
    "some Warn"(W)
}

When used with the FormatterBuilder configuration from the next section, the output can look like this:

DesktopMain    [Verbose] ⬜ --->    DesktopMainKt.invoke(DesktopMain.kt:24) multi log
    🟥 -> some Error
    🟩 -> some Info
    🟦 -> some Debug
    ⬜ -> some Verbose
    🟨 -> some Warn some custom text

FormatterBuilder is shared and can be configured the same way for Android, desktop JVM, and iOS by passing the built IFormatter into LoKdroid.initialize.

Platform behavior for withLineReference():

• Android: inserts a compact reference like MainScreen.kt:42
• Desktop JVM: inserts a stack-frame-style reference like MainScreen.onClick(MainScreen.kt:42)
• iOS: inserts the same stack-frame-style reference format as desktop

Before formatting the line reference, LoKdroid skips its own internal wrapper frames such as LoKdroid, LogManager, and LogFunctions*, then uses the first external frame that remains.

LoKdroid.initialize(
    formatter = FormatterBuilder()
        .withPointer()        // adds "--->"
        .space()              // adds a space
        .withLineReference()  // Android: File.kt:123, Desktop/iOS: Class.method(File.kt:123)
        .space()
        .message()            // MANDATORY: injects your original log message
        .space()
        .custom(text = "some custom text") // appends any custom text
        .build()
)

• Android ConsoleLogger writes through the platform logging system, so logs appear in Logcat with Android priorities.
• Desktop JVM and iOS ConsoleLogger write formatted lines to standard output using the pattern Tag<TAB>[Level] emoji message.
• The default desktop and iOS level markers use square emoji blocks: ⬜, 🟦, 🟩, 🟨, 🟥.
• The default tagProvider derives the tag from the caller file name without the .kt extension when source metadata is available.

Desktop and iOS example output:

SharedUiScreens    [Debug] 🟦 --->    SharedUiScreensKt.invokeMultipleLog(SharedUiScreens.kt:293) Multiple log

fun initialize(
    minLevel: Level = Level.Verbose,
    logger: ILogger = ConsoleLogger,
    formatter: IFormatter = IFormatter { message -> message },
    tagProvider: () -> String = { TagProvider.getTag() },
    messageBuilderFactory: () -> IMessageBuilder = { MessageBuilder() }
)

Available implementations:

• ConsoleLogger is available on Android, desktop JVM, and iOS.
• FileLogger is Android-only and writes messages to a file. It supports Android Studio Logcat import format.
• ConsoleAndFileLogger is Android-only.
• RemoteLogger is currently Android-only.

/** custom implementation */

LoKdroid.initialize(
    minLevel = Level.Debug,
    logger = { level: Level, tag: String, message: String -> /** your logic */ },
    formatter = { message -> "return formatted message: $message" },
    tagProvider = { "custom tag" },
    messageBuilderFactory = {
        object : IMessageBuilder {
            override fun build(): String = "build your string"

            override operator fun String.invoke(level: Level?) {
                // use this block to build multiple message lines
            }
        }
    }
)

Platform visibility:

• commonMain sees the shared API, including LoKdroid, log functions, ILogger, IFormatter, IMessageBuilder, ConsoleLogger, and FormatterBuilder.
• androidMain also sees Android-only implementations such as FileLogger, ConsoleAndFileLogger, RemoteLogger, and FileFormat.
• desktopMain and iosMain use the same shared API surface and platform-specific console behavior under the hood.

Console defaults:

• The default tag on Android, desktop JVM, and iOS is derived from the caller file name, for example SharedUiScreens.
• Desktop and iOS keep stack-frame-style line references, so top-level Kotlin functions still appear with synthetic owners such as SharedUiScreensKt.invoke(...).
• Caller resolution skips internal LoKdroid wrappers only. If you log through your own helper or extension function, that helper becomes the resolved caller unless you provide a custom tagProvider.

This project is licensed under the Apache License, Version 2.0. See the LICENSE file for more details.