Kotlin Multiplatform: как писать код один раз и покорить все платформы

Автор статьи: Сергей Прощаев (@sproshchaev), Руководитель направления Java-разработки в FinTech

Введение 

Kotlin давно перерос статус языка «только для Android». Благодаря технологии Kotlin Multiplatform (KMP), он позволяет создавать приложения, которые работают на JVM, iOS, macOS, вебе и других платформах, сохраняя единый код бизнес-логики. 

В отличие от React Native, Flutter или Xamarin, KMP не навязывает свои UI-компоненты, а интегрируется с нативными инструментами, что делает его гибким инструментом для кросс-платформенной разработки.

Почему Kotlin Multiplatform выделяется из остальных решений?

Традиционные фреймворки требуют писать UI и платформенные функции на их собственных API, что часто приводит к изучению новых инструментов и дублированию кода. KMP, в отличие от этого, предлагает иной подход: 

1. Общий код (например, бизнес-логика, алгоритмы, работа с данными) пишется один раз на Kotlin. 

2. Платформенный код (UI, доступ к железу) реализуется отдельно для каждой системы с использованием её родных технологий. Это устраняет необходимость изучать несколько UI-фреймворков и позволяет использовать уже знакомые инструменты, такие как Swift для iOS или Jetpack Compose для Android.

В условиях растущего спроса на приложения, работающие на множестве платформ, KMP выделяется как передовая технология, отвечающая вызовам современной разработки. Вместо создания изолированных кодовых баз для iOS, Android, веба или десктопа, KMP позволяет разделять до 80% кода — включая бизнес-логику, работу с сетью и аналитику — между всеми платформами. Это не только сокращает затраты времени и ресурсов, но и гарантирует консистентность функционала, упрощая поддержку и последующие обновления продукта.

Кроме того, KMP позволяет упрощать тестирование. Ведь общий код тестируется один раз, а его независимость от платформенных деталей уменьшает количество потенциальных ошибок. Разработчики могут сосредоточиться на сложных задачах, вместо того чтобы дублировать рутинные операции для каждой ОС. 

Как будет выглядеть классический “Hello, World!”, реализуемый на Kotlin Multiplatform для четырёх платформ?

Безусловно то, что невозможно рассказать все о KMP в рамках одной статьи, но возможно описать основные принципы, которые заложены в этом подходе.

Для начала разберем типовую структуру самого простого проекта на Kotlin, содержащего код для нескольких платформ:

my-kmp-project/
├── build.gradle.kts
└── src/
    ├── commonMain/
    │   └── kotlin/
    │       └── Common.kt  
    ├── jvmMain/
    │   └── kotlin/
    │       └── JvmPlatform.kt 
    ├── jsMain/
    │   └── kotlin/
    │       └── JsPlatform.kt  
    ├── iosArm64Main/
    │   └── kotlin/
    │       └── IosPlatform.kt 
    └── macosX64Main/
        └── kotlin/
            └── MacosPlatform.kt 

В commonMain содержится код, общий для всех платформ. В Common.kt выносим логику, которая не зависит от конкретной платформы:

expect fun platformName(): String

fun greet() {
    println("Hello, ${platformName()}!")
}

Далее каждый каталог вида <target>Main содержит реализации для конкретной платформы.

В каталог jvmMain в JvmPlatform.kt помещаем JVM-специфичный код, который работает на Windows, Linux, macOS через виртуальную машину Java:

actual fun platformName(): String = "JVM"

В jsMain в JsPlatform.kt будет находится JavaScript-код для браузеров и Node.js:

actual fun platformName(): String = "JavaScript"

В iosArm64Main в файл IosPlatform.kt пишем нативный код для iOS-устройств: 

actual fun platformName(): String = "iOS"

В macosX64Main создаем файл MacosPlatform.kt для нативного кода macOS:

actual fun platformName(): String = "macOS"

В конфигурацию build.gradle.kts добавляем:

plugins {
    kotlin("multiplatform") version "1.9.20"
}

kotlin {
    jvm()          // Для Windows, Linux, macOS (JVM)
    macosX64()     // macOS x64
    iosArm64()     // iOS ARM64
    js(IR) {       // JavaScript
        browser()
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(kotlin("stdlib-common"))
            }
        }
        val jvmMain by getting { dependencies { implementation(kotlin("stdlib-jdk8")) } }
        val jsMain by getting { dependencies { implementation(kotlin("stdlib-js")) } }
    }
}

В блоке kotlin { ... } у нас определены целевые платформы: jvm(), macosX64(),  iosArm64() и js(IR). 

Блок sourceSets { ... } описывает расположение исходников и зависимостей для каждой из платформ:

1. commonMain — содержит общую логику для всех платформ, которая размещается в каталоге src/commonMain/kotlin,

2. jvmMain — указывает на код для JVM, расположенный в каталоги src/jvmMain/kotlin и зависимость stdlib-jdk8 которая предоставляет нашему проекту расширенную библиотеку для работы с JVM/JDK 8+,

3. jsMain — определяет каталог src/jsMain/kotlin с исходниками для JavaScript и зависимость stdlib-js в которой находится библиотека, адаптированная для JS. В последних версиях Kotlin stdlib-js подключается автоматически и ее можно не указывать явно.

Для iosArm64Main и macosX64Main зависимости не указаны — они используют stdlib-common по умолчанию.

Как это работает?

При компиляции Gradle объединяет общий код, который находится в commonMain с платформенным кодом. Например, для сборки под macOS: 

1. берётся Common.kt из commonMain, 

2. добавляется MacosPlatform.kt из macosX64Main, 

3. и все компилируется в нативный macOS-бинарник.

Этот процесс автоматически разрешает зависимости между общим и платформенным кодом. Такой подход гарантирует, что бизнес-логика остаётся единой, а платформенные нюансы обрабатываются локально, что упрощает поддержку и тестирование.

Заключение или почему все-таки Kotlin Multiplatform актуален сегодня?

1. Универсальность без компромиссов: KMP не ограничивает выбор инструментов: он гармонично интегрируется с нативными фреймворками (SwiftUI, Jetpack Compose, React) и позволяет использовать платформенные API там, где это необходимо. Например, UI остаётся нативным, а логика обработки данных — общей. Это делает приложения производительными и соответствующими гайдлайнам каждой ОС. 

2. Поддержка всех ключевых платформ: c KMP можно компилировать код для JVM (Android, серверы), iOS/macOS (через нативные бинарники), JavaScript (фронтенд/бэкенд) и даже встраиваемых систем. Такая гибкость критически важна для проектов, где требуется охват desktop-, mobile- и web-аудитории. 

3. Активное развитие и индустриальная поддержка: JetBrains, который  является создателем Kotlin, постоянно улучшает KMP, добавляя поддержку новых платформ (например, Kotlin/Wasm) и интеграцию с инструментами вроде Xcode и CocoaPods. 

Технология активно используется гигантами типа Netflix, CashApp и Autodesk, что подтверждает её зрелость и применимость в production. 

KMP — это не просто «ещё один кроссплатформенный инструмент», а целое  стратегическое решение для команд, которые стремятся к эффективности, сохраняя при этом качество и нативный пользовательский опыт. В условиях, где время вывода продукта на рынок и поддержка множества платформ становятся ключевыми факторами успеха, Kotlin Multiplatform предлагает оптимальный баланс между унификацией и гибкостью!

---

Если вы хотите глубже разобраться в возможностях Kotlin, заглянуть за рамки привычной разработки и изучить реальные приёмы, которые применяются в продакшене — присмотритесь к ближайшим занятиям в Otus. Это не обзорные лекции, а практичные уроки по конкретным темам:

• 14 мая 20:00
  Kotlin Multiplatform: лайфхак для Java-разработчиков
  Узнаем, как писать один код для Android, iOS и backend и внедрить его в существующие Java-проекты.

• 22 мая 20:00
  Возможности Kotlin для создания DSL на примере JsonBuilder
  Обсудим практику написания собственных DSL, замыкания и extension-функции на живом примере.

А если вам интересно узнать свой уровень знаний Kotlin, пройдите вступительное тестирование.