RizTech Academy logo
RizTech Academy

Kotlin Multiplatform with Compose

One Kotlin codebase, two native apps — Android and iOS, sharing logic and interface.

Writing the same app twice, in two languages, by two teams, is how most companies still build for mobile. Kotlin Multiplatform lets you write the logic once in Kotlin and compile it natively for both, and Compose Multiplatform lets you share the interface too if you want to.

The important word is natively. This is not a web view in a wrapper. Your Kotlin compiles to real Android bytecode and to a real native iOS framework, and both apps behave like the platform they are on.

This course is honest about the trade-offs, because they are real. Shared UI is not always the right answer, iOS tooling is less mature than Android, and some problems are genuinely easier solved twice. There is a module on deciding what to share and what to leave alone, and it matters more than any of the code.

You need a Mac only for the final iOS build and release. Everything before that runs on any machine, which is why this is the practical route to an iPhone app for most people in India.

Who this is for

  • Android developers who want to ship for iPhone without learning Swift first
  • Teams tired of building and maintaining the same app twice
  • Developers who have finished our Kotlin Foundation course
  • Anyone choosing between native, React Native and Flutter who wants the real trade-offs

What you need first

  • Solid Kotlin. Our Kotlin Complete Foundation course covers what is assumed here.
  • Some Android experience helps a great deal but is not strictly required.
  • Any machine will do for most of the course. A Mac is needed only to build, test and release the iOS app.

Tools you will use

Kotlin MultiplatformCompose MultiplatformAndroid StudioXcodeKtorSQLDelightKoinGradle

By the end you can

  • Set up a Kotlin Multiplatform project that builds for Android and iOS
  • Decide deliberately what to share and what to write twice
  • Structure source sets so shared and platform code stay separate
  • Use expect/actual to reach platform APIs from shared code
  • Build a shared interface with Compose Multiplatform
  • Call APIs with Ktor and store data with SQLDelight, once for both platforms
  • Call your shared Kotlin from Swift, and understand what the bridge does to your types
  • Test shared code once instead of twice
  • Release both apps from one codebase
Syllabus

13 modules, 58 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Why Multiplatform, and When Not To

    The honest case, including the situations where writing it twice is the better call.

    1. The cost of building the same app twiceComing soon
    2. How KMP compiles Kotlin to two native targetsComing soon
    3. KMP versus Flutter and React NativeComing soon
    4. What to share, and what to leave platform-specificComing soon
    5. When multiplatform is the wrong answerComing soon
  2. 2

    Setting Up

    Getting both targets building, which is the steepest part of the whole course.

    1. Android Studio, the KMP plugin and XcodeComing soon
    2. Creating a project that builds for bothComing soon
    3. Running on AndroidComing soon
    4. Running on iOS, and what you need a Mac forComing soon
    5. When the build breaks: the usual causesComing soon
  3. 3

    Project Structure and Source Sets

    Where code lives, and why that is the whole design.

    1. commonMain, androidMain, iosMainComing soon
    2. Gradle in a multiplatform projectComing soon
    3. Adding dependencies, shared and platformComing soon
    4. Splitting into modules as the app growsComing soon
  4. 4

    Writing Shared Code

    The Kotlin that runs on both, and the standard library that comes with it.

    1. What Kotlin you can use in common codeComing soon
    2. Coroutines and flows across platformsComing soon
    3. kotlinx.serializationComing soon
    4. Dates and times without a platform libraryComing soon
    5. Putting the logic that matters in shared codeComing soon
  5. 5

    expect / actual and Platform APIs

    Reaching platform-specific features from shared code.

    1. expect and actual, explainedComing soon
    2. Calling Android and iOS APIsComing soon
    3. Dependency injection instead of expect/actualComing soon
    4. Which approach to use whenComing soon
  6. 6

    Compose Multiplatform

    One declarative interface, rendered on both platforms.

    1. Composable functions and recompositionComing soon
    2. Layout: Row, Column and BoxComing soon
    3. State and rememberComing soon
    4. Theming, and looking right on both platformsComing soon
    5. Images, fonts and strings across targetsComing soon
    6. When shared UI feels wrong, and what to doComing soon
  7. 7

    Architecture and Navigation

    Structuring an app that two platforms have to live with.

    1. Choosing an architecture for shared codeComing soon
    2. Shared view modelsComing soon
    3. Navigation in Compose MultiplatformComing soon
    4. Dependency injection with KoinComing soon
  8. 8

    Networking with Ktor

    One HTTP client for both platforms.

    1. Ktor client setupComing soon
    2. Requests, responses and typed modelsComing soon
    3. Errors, retries and offlineComing soon
    4. Authenticated requests and token storageComing soon
  9. 9

    Storing Data

    A database that works the same on an iPhone and an Android.

    1. SQLDelight: typed SQL for both platformsComing soon
    2. Queries, migrations and flowsComing soon
    3. Key-value storage across platformsComing soon
    4. Building offline-first, and syncing laterComing soon
  10. 10

    Talking to Swift and Android

    The seam where your Kotlin meets the platform, and where the surprises live.

    1. Calling shared Kotlin from SwiftComing soon
    2. What happens to your types across the bridgeComing soon
    3. Suspend functions and flows from SwiftComing soon
    4. Writing one screen natively when it is worth itComing soon
  11. 11

    Testing

    Write the test once, run it on both.

    1. Testing shared codeComing soon
    2. Platform-specific testsComing soon
    3. Testing Compose UIComing soon
  12. 12

    Shipping Both Apps

    Two stores, two review processes, one codebase.

    1. Build types, flavours and configurationComing soon
    2. Releasing to Google PlayComing soon
    3. Releasing to the App StoreComing soon
    4. Building both in CIComing soon
    5. Versioning and releasing two apps at onceComing soon
  13. 13

    Capstone Project

    One codebase, two apps, both on a real device.

    1. The brief: a shared expenses appComing soon
    2. Deciding what to share before writing anythingComing soon
    3. Building the shared coreComing soon
    4. Building the interfaceComing soon
    5. Getting both onto a real phoneComing soon
Previous courseDevOps Complete FoundationNext courseFull-Stack Web Development with Next.js and NestJS

Learning this with a mentor is faster

Our internship programme is free and fully remote. You get this curriculum, real project work, and code review from working developers.

Apply for the internshipAll courses