Coming June 2026

Share Kotlin
across native
Android & iOS.

Build Android and iOS apps using shared Kotlin code, while keeping the UI completely native on each platform. Learn practical patterns that work in production.

Notify me at launch → See what's inside
What's inside

Networking

Using Ktor, you'll learn how to create a REST API networking setup that can be shared across platforms. We'll be using the Firebase REST API to authenticate users, as well as read and manage user data.

Caching

Using the Room multiplatform database, we'll create a cache layer that is shared across platforms. This will be used to cache data that we retrieve from Firebase, allowing us to repurpose it for required functionality in our app.

Shared Code

Learn how to create shared code modules that can be imported as dependencies for different platforms of your app, as well as covering how to provide different implementations per-platform where required.

Modularisation

So that our project is well organized, you'll learn how to create multiplatform libraries, shared code modules and also how to organize platform specific code in isolated modules for improved navigation throughout the project.

Testing

While being able to write multiplatform code is a huge benefit in itself, you'll also be learning how to write tests for this shared code to prevent any regressions across platforms.

Jetpack Compose

We'll be creating a native Android app using Jetpack Compose - replicating how this will look in your team and allowing us to keep the UI completely native while utilising shared multiplatform code.

Swift UI

We'll be creating a native iOS app using Swift UI - replicating how this will look in your team and allowing us to keep the UI completely native while utilising shared multiplatform code.

Dependency Injection

We'll be setting up dependency injection using Koin, creating a shared DI graph that can be consumed across both the Android and iOS apps.

What you'll build

Jrnl: a journalling app for Android and iOS.

Throughout the course we'll be building Jrnl, a journalling app that runs natively on both Android and iOS. Users can create an account, sign in, view their journal entries, create new ones and manage existing ones, all powered by a shared Kotlin core.

The Android app is built with Jetpack Compose, the iOS app with SwiftUI. Both share the same business logic, networking, persistence and state management underneath.

  • Authentication: create an account or sign in
  • Feed: view all journal entries
  • Composer: create new journal entries
  • Management: edit and delete existing entries
Jrnl sign in screen
Jrnl entries screen
Jrnl new entry screen
Architecture
Jetpack Compose SwiftUI SHARED · KOTLIN Presentation Domain Network Cache Settings Dependency Injection

Native UI, Shared Logic.

Each platform handles its own UI: navigation, layout, animation, and anything else that benefits from being native. Everything underneath that lives in shared Kotlin code.

This means the parts you don't want to write twice (business logic, networking, persistence, state management) get shared across both platforms. The parts your users actually see and interact with stay native.

  • Native UI on each platform: Compose for Android, SwiftUI for iOS
  • Shared presentation: ViewModels, state holders, reducers
  • Shared data layer: networking, caching, persistence
  • One DI graph: Koin modules consumed by both platforms
Stack
Kotlin Multiplatform
Core language
Jetpack Compose
Android UI
SwiftUI
iOS UI
Ktor
Networking
Room
Local database
Firebase
Backend services
Koin
Dependency injection
Multiplatform Settings
Key–value storage
Coroutines & Flow
Async & reactive
Kotlinx Serialization
JSON · Protobuf
kotlin-test & Turbine
Testing
Version Catalogs
Build configuration
The course

Two ways to learn it.

Read the book cover to cover, or work through the same material as an interactive, progress-tracked course.

The book
Practical Kotlin Multiplatform book cover

What's in the book.

Formats
PDF · ePub · azw3 · HTML read on any device
Length
Approximately 1,000+ pages across four parts
Source code
Full Android & iOS apps, shared module, tests
Updates
Free corrections and revisions for the first edition
The platform

The same book, as an interactive course.

Every chapter becomes a trackable lesson. Move through the curriculum part by part, mark what you've finished, and pick up exactly where you left off.

  • 65 parts across 8 structured sections
  • Progress tracking as you complete each part
  • Native Android & iOS chapters, built side by side
  • Full source code linked inline at every step
  • Earn a certificate of completion when you finish all 65 parts
The curriculum 65 / 65 parts
Section One01 / 08

Foundations

pp. 1–13 · 3 parts
Complete 3 / 3
Section Two02 / 08

Authentication Networking

pp. 14–108 · 8 parts
Complete 8 / 8
Section Five05 / 08

Use Cases & View Models

pp. 230–410 · 10 parts
In progress 6 / 10
Section Seven07 / 08

Building the Android App

pp. 478–790 · 18 parts
Not started 0 / 18

One price: the book and the course.

A single purchase gets you the complete book in every format and full access to the interactive course, including all source code and future updates. Purchasing power parity is applied automatically.

$99
One-time · Book + course · Includes updates
Notify me at launch →
About the author
Joe Birch

Joe Birch

Joe is a Google Developer Expert for Android with over 12 years of experience in mobile development. He writes regularly about Android development at joebirch.co, covering everything from Jetpack Compose to Kotlin Multiplatform.

He's also the author of Practical Jetpack Compose, a course covering the Compose UI toolkit from fundamentals through to production patterns.

joebirch.co LinkedIn Practical Jetpack Compose
FAQ
Who is this course actually written for?
This course is perfect for Android and iOS developers who want to share code between platforms while keeping native UI. Whether you're a senior developer evaluating KMP adoption or a team lead looking to reduce code duplication, you'll gain practical skills applicable to real-world projects.
Do I need prior Kotlin Multiplatform experience?
No prior KMP experience is required. You should be comfortable with Kotlin development and have basic Android or iOS development knowledge. We'll start with the fundamentals and build up to advanced architectural patterns.
Why not Compose Multiplatform for the UI?
While Compose Multiplatform is exciting, some production teams prefer keeping the UI native for platform-specific user experiences, easier integration with existing apps, and team expertise. This course teaches you to maximise code sharing where it matters most: business logic, networking, and the data layer.
Are pricing adjustments available outside the US/UK?
Yes. We believe quality education should be accessible worldwide, so purchasing power parity (PPP) discounts are applied automatically based on your location. This makes the course affordable while maintaining the same content and support.
Will I get the complete source code?
Yes, you'll receive the complete source code for both the Android and iOS apps, including all of the shared modules. The code is well-documented and organised so you can use it as a reference for your own projects.
What's the refund policy?
Because this is a digital product, refunds aren't supported. A free preview will be available before launch, so you can check the content fits what you're looking for before purchasing.