Architecting a Kotlin Multiplatform Library for iOS and Android

For a small team of 2 engineers building a shared business logic and data layer library for internal use across iOS and Android, here's a practical approach to architecting your Kotlin Multiplatform (KMP) library:

Project Structure

Set up your project with a clear module structure:

my-kmp-library/
├── shared/
│   ├── src/
│   │   ├── commonMain/ (shared code)
│   │   ├── androidMain/ (Android-specific implementations)
│   │   └── iosMain/ (iOS-specific implementations)
├── androidApp/ (optional sample app)
└── iosApp/ (optional sample app)

Dependency Configuration

In your build.gradle.kts file, configure dependencies for your shared module:

KOTLINCopied
kotlin {
    androidTarget()
    iosX64()
    iosArm64()
    iosSimulatorArm64()
    
    sourceSets {
        commonMain.dependencies {
            // Core Kotlin libraries
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
            implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2")
            
            // Networking
            implementation("io.ktor:ktor-client-core:2.3.7")
            implementation("io.ktor:ktor-client-content-negotiation:2.3.7")
            implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.7")
            
            // Database
            implementation("app.cash.sqldelight:runtime:2.0.1")
        }
        
        androidMain.dependencies {
            implementation("io.ktor:ktor-client-android:2.3.7")
            implementation("app.cash.sqldelight:android-driver:2.0.1")
        }
        
        iosMain.dependencies {
            implementation("io.ktor:ktor-client-darwin:2.3.7")
            implementation("app.cash.sqldelight:native-driver:2.0.1")
        }
    }
}

Architecture Recommendations

1. Layer Your Architecture

┌─────────────────────────────────────┐
│           Domain Layer              │
│  (Business Logic, Models, UseCases) │
└───────────────┬─────────────────────┘
                │
┌───────────────▼─────────────────────┐
│           Data Layer                │
│  (Repositories, Data Sources)       │
└───────────────┬─────────────────────┘
                │
┌───────────────▼─────────────────────┐
│      Platform-Specific Layer        │
│  (expect/actual implementations)    │
└─────────────────────────────────────┘

2. Use expect/actual Sparingly

Define platform-specific implementations only when necessary:

KOTLINCopied
// In commonMain
expect class PlatformDatabase {
    suspend fun storeData(key: String, value: String)
    suspend fun getData(key: String): String?
}

// In androidMain
actual class PlatformDatabase {
    actual suspend fun storeData(key: String, value: String) {
        // Android-specific implementation
    }
    
    actual suspend fun getData(key: String): String? {
        // Android-specific implementation
    }
}

// In iosMain
actual class PlatformDatabase {
    actual suspend fun storeData(key: String, value: String) {
        // iOS-specific implementation
    }
    
    actual suspend fun getData(key: String): String? {
        // iOS-specific implementation
    }
}

3. Recommended Libraries

For a small team, focus on these battle-tested libraries:

• Networking: Ktor Client
• Serialization: Kotlinx Serialization
• Database: SQLDelight
• Dependency Injection: Koin (lightweight) or Kodein
• Concurrency: Kotlinx Coroutines
• Date/Time: Kotlinx DateTime

4. API Design for Platform Consumption

Create a clean API that's easy to consume from both platforms:

KOTLINCopied
// Simple API for platform consumption
class UserRepository(private val api: ApiClient, private val db: Database) {
    suspend fun getUser(id: String): User {
        // Implementation details hidden from platform code
    }
    
    suspend fun saveUser(user: User) {
        // Implementation details hidden from platform code
    }
}

5. Testing Strategy

Set up a testing structure in your commonTest source set to ensure your shared code works consistently:

KOTLINCopied
// In build.gradle.kts
sourceSets {
    commonTest.dependencies {
        implementation(kotlin("test"))
        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")
    }
}

Integration with Native Apps

For Android:

KOTLINCopied
// In your Android app's build.gradle.kts
dependencies {
    implementation(project(":shared"))
}

For iOS:

Use the generated framework in your Swift code:

SWIFTCopied
import SharedLibrary

// Use your KMP code
let repository = UserRepository()

Practical Tips for a Small Team

1. Start small: Begin with a focused subset of your business logic
2. Iterate quickly: Get feedback from both platforms early
3. Avoid over-engineering: For a small team, simplicity is key
4. Document as you go: Create simple documentation for future reference
5. Set up CI/CD: Automate testing and distribution of your library

This approach provides a solid foundation for a small team to build and maintain a shared Kotlin Multiplatform library for internal use.