PeopleInSpace

Kotlin Multiplatform project with SwiftUI, Jetpack Compose, Compose for Wear OS, Compose for Desktop and Compose for Web clients along with Ktor backend. Currently running on

• Android (Jetpack Compose)
• Android App Widget (Compose based Glance API - contributed by https://github.com/yschimke)
• Wear OS (Compose for Wear OS - primarily developed by https://github.com/yschimke)
• iOS (SwiftUI)
• Swift Executable Package
• Desktop (Compose for Desktop)
• Web (Compose for Web - Wasm based)
• Windows (WinUI 3)
• JVM (small Ktor back end service + Main.kt in common module)
• MCP server (using same shared KMP code)

The people data comes from The Space Devs API (names, bios and images of the people currently in space) and the position of the International Space Station from the Where the ISS at? API, both served through this project's own small Ktor backend (see backend module below).

The project is included as sample in the official Kotlin Multiplatform docs and also the Google Dev Library

Module overview

Module	Description
common	Shared KMP code (Ktor, SQLDelight, Koin, view models), shared Compose Multiplatform UI, and the Windows NuGet API
app	Android client (Jetpack Compose), including Glance app widget
wearApp	Wear OS client (Compose for Wear OS)
PeopleInSpaceSwiftUI	iOS client (SwiftUI)
compose-desktop	Desktop client (Compose for Desktop)
compose-web	Web client (Compose for Web, Kotlin/Wasm)
windows/WinUiApp	Windows client (WinUI 3)
backend	Ktor server providing the people/ISS data (deployable to Google App Engine)
mcp-server	Model Context Protocol server exposing the shared KMP code

Building and running

Requirements: JDK 17, a recent version of Android Studio (for the Android/Wear clients) and Xcode (for the iOS client).

• Android: run the app configuration from Android Studio (or ./gradlew :app:installDebug)

• Wear OS: run the wearApp configuration from Android Studio (or ./gradlew :wearApp:installDebug)

• iOS: open PeopleInSpaceSwiftUI in Xcode and run from there

• Desktop: ./gradlew :compose-desktop:run

• Web (Wasm): ./gradlew :compose-web:wasmJsBrowserDevelopmentRun

• Windows (.NET): see the WinUI 3 client guide for prerequisites and build, test, and run instructions.

• Backend: ./gradlew :backend:run (or run Server.kt directly from Android Studio). After doing that you should then for example be able to open http://localhost:9090/astros_local.json in a browser.

Tests can be run with ./gradlew :common:jvmTest, and there's also a Maestro UI test flow for the Android client (maestro test maestro/PeopleInSpace.flow).

Backend deployment

Have tested this out in Google App Engine deployment. Using shadowJar plugin to create an "uber" jar and then deploying it as shown below. Should be possible to deploy this jar to other services as well.

./gradlew :backend:shadowJar
gcloud app deploy backend/build/libs/backend-all.jar --appyaml=backend/src/jvmMain/appengine/app.yaml

Screenshots

iOS (SwiftUI + CMP)

Android (Jetpack Compose + CMP)

Wear OS (Wear Compose)

Compose for Desktop

Compose for Web (Wasm based)

MCP

The mcp-server module uses the Kotlin MCP SDK to expose an MCP tools endpoint (returning list of people in space) that can for example be plugged in to Claude Desktop as shown below. That module uses same KMP shared code (that uses for example Ktor, SQLDelight and Koin)

To integrate the MCP server with Claude Desktop you need to firstly run gradle shadowJar task and then select "Edit Config" under Developer Settings and add something like the following (update with your path)

{
  "mcpServers": {
    "kotlin-peopleinspace": {
      "command": "java",
      "args": [
        "-jar",
        "<path-to-repo>/mcp-server/build/libs/serverAll.jar",
        "--stdio"
      ]
    }
  }
}

Related posts

• Minimal Kotlin Multiplatform project using Compose and SwiftUI
• Adding some Storage (to) Space
• Kotlin Multiplatform running on macOS
• PeopleInSpace hits the web with Kotlin/JS and React
• Using Koin in a Kotlin Multiplatform Project
• Jetpack Compose for the Desktop!
• Comparing use of LiveData and StateFlow in a Jetpack Compose project
• Wrapping Kotlin Flow with Swift Combine Publisher in a Kotlin Multiplatform project
• Using Swift Packages in a Kotlin Multiplatform project
• Using Swift's new async/await when invoking Kotlin Multiplatform code
• Exploring new AWS SDK for Kotlin
• Creating a Swift command line app that consumes Kotlin Multiplatform code
• Exploring New Worlds of UI sharing possibilities in PeopleInSpace using Compose Multiplatform

Related samples

Note that this repository very much errs on the side of minimalism to help more clearly illustrate key moving parts of a Kotlin Multiplatform project and also to hopefully help someone just starting to explore KMP to get up and running for first time (and is of course primarily focused on use of Jetpack Compose and SwiftUI). If you're at the stage of moving beyond this then I'd definitely recommend checking out KaMPKit from Touchlab. I also have the following samples that demonstrate the use of a variety of Kotlin Multiplatform libraries (and also use Jetpack Compose and SwiftUI).

• GalwayBus (https://github.com/joreilly/GalwayBus)
• Confetti (https://github.com/joreilly/Confetti)
• BikeShare (https://github.com/joreilly/BikeShare)
• FantasyPremierLeague (https://github.com/joreilly/FantasyPremierLeague)
• ClimateTrace (https://github.com/joreilly/ClimateTraceKMP)
• GeminiKMP (https://github.com/joreilly/GeminiKMP)
• MortyComposeKMM (https://github.com/joreilly/MortyComposeKMM)
• StarWars (https://github.com/joreilly/StarWars)
• WordMasterKMP (https://github.com/joreilly/WordMasterKMP)
• Chip-8 (https://github.com/joreilly/chip-8)

Languages, libraries and tools used

• Kotlin
• Kotlin Coroutines
• Kotlinx Serialization
• Ktor client library
• Android Architecture Components
• Koin (using Koin Annotations and the Koin compiler plugin)
• SQLDelight
• Jetpack Compose
• Compose Multiplatform
• Compose for Wear OS
• SwiftUI
• SKIE
• Coil
• Kermit
• Maestro