Share Kotlin
across Android, iOS,
web & desktop.

Build Android and iOS apps using shared Kotlin code, with the UI built both ways: native with Compose and SwiftUI, and shared with Compose Multiplatform. The shared-UI path, plus web and desktop, is coming soon. Practical patterns that work in production.

Buy now → Free preview 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 every platform.

Compose Multiplatform Coming soon

We'll also build the UI once with Compose Multiplatform and share it across platforms, so you cover both the native and shared approaches side by side. Coming as a free update.

Web & Desktop Coming soon

We'll take the same shared code and Compose Multiplatform UI to the browser and the desktop, all from one Kotlin codebase. Coming as a free update.

What you'll build

Jrnl: a journalling app for Android and iOS.

Coming soon: web & desktop

Throughout the course we'll be building Jrnl, a journalling app that runs natively on both Android and iOS (desktop and web coming soon). 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. You'll also rebuild Jrnl's UI with Compose Multiplatform, sharing it across platforms (coming soon).

  • 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
Android iOS Web COMING SOON Desktop COMING SOON SHARED · KOTLIN Presentation Domain Network Cache Settings Dependency Injection

Native UI and Compose Multiplatform.

You'll build the UI two ways, because they fit different projects. Native, with Compose on Android and SwiftUI on iOS, keeps each platform feeling its own. It's also the easiest way to bring Kotlin Multiplatform into an app you already have: the shared code slots in underneath a native UI, no rewrite required. Shared, with Compose Multiplatform, shares the UI itself, so one UI runs across platforms. That path is coming as a free update.

Either way, the parts you don't want to write twice (business logic, networking, persistence, state management) stay shared across platforms. What you choose is how much of the UI to share on top.

  • Native UI on each platform: Compose for Android, SwiftUI for iOS
  • Shared UI with Compose Multiplatform: one UI across platforms (coming soon)
  • Shared presentation: ViewModels, state holders, reducers
  • Shared data layer: networking, caching, persistence
  • One DI graph: Koin modules consumed across platforms
Stack
Kotlin Multiplatform
Core language
Jetpack Compose
Android UI
SwiftUI
iOS UI
Compose Multiplatform
Shared 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
Coming soon

Compose Multiplatform, desktop and web.

Native Compose and SwiftUI in the version available today. Next, the course grows to cover Compose Multiplatform for shared UI, and desktop and web as build targets from the same Kotlin codebase.

Coming soon

Compose Multiplatform

Share the UI itself across platforms, alongside the native Compose and SwiftUI approach you already get.

Coming soon

Desktop

Run the same app on desktop from the shared code you've already built.

Coming soon

Web

Target the browser from the same Kotlin codebase.

All of it lands as a free update. The price rises to $119 once it's complete, so buy now at $79 and get the Compose Multiplatform, desktop and web material at no extra cost.

The course

Two ways to learn it.

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

The book
Practical Kotlin Multiplatform book cover

What's in the book.

Formats
PDF · ePub · azw3 · mobi read on any device
Length
Approximately 940+ pages across four parts
Source code
Full Android & iOS apps, shared module and tests, with the Compose Multiplatform, web and desktop code to follow
Updates
Free updates, including the Compose Multiplatform, desktop & web material as it ships
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
  • Compose Multiplatform chapters for shared UI (coming soon)
  • 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
Coming soonFree update

Compose Multiplatform, web & desktop

Shared UI and new build targets
Coming soon

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 every future update, the coming Compose Multiplatform, desktop and web material included. Individual purchases get automatic purchasing power parity. Buying for your team? Switch to team pricing and set your seat count.

Buy now to lock in $79. The price rises to $119 once the Compose Multiplatform, desktop and web material is complete, and every update stays free.

$79
$119
One-time · Book + course · Includes updates
Buy now →
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 written for?
It's for Android and iOS developers who want to share code between platforms, whether you keep the UI native or share it with Compose Multiplatform. Maybe you're weighing up KMP for your team, or you just want to stop writing the same logic twice. The patterns here carry straight into real 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.
Does it cover Compose Multiplatform, desktop and web?
Native Compose and SwiftUI are covered now. Compose Multiplatform for shared UI, plus desktop and web as build targets, is coming as a free update. Buy before the price goes up and you get all of it at no extra cost.
Are pricing adjustments available outside the US/UK?
Yes. Purchasing power parity (PPP) discounts are applied automatically based on your location, so the price adjusts to where you are. Same content either way.
Will I get the complete source code?
Yes, you'll receive the complete source code for the Android and iOS apps and all the shared modules, with the Compose Multiplatform, web and desktop code added as it ships. The code is well 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 is available, so you can check the content fits what you're looking for before purchasing.