joreilly/PeopleInSpace

This system is a multiplatform application that tracks the International Space Station's position and lists astronauts currently in space. It shares a common Kotlin data layer and business logic across Android, iOS, Wear OS, Desktop, Web, and Windows clients. The architecture leverages Kotlin Multiplatform, Compose Multiplatform, and Koin for dependency injection, with a Ktor-based backend providing the underlying API.

22 changes.

The project underwent a comprehensive overhaul to modernize its multiplatform architecture, migrating the build system to Gradle Version Catalogs and Kotlin DSL while upgrading core dependencies like Koin, Ktor, and Compose. Significant structural changes included removing legacy Android and iOS boilerplate, eliminating CocoaPods in favor of Swift Package Manager, and consolidating dependency injection and data handling into shared code. These efforts were accompanied by documentation updates and the addition of Compose UI tests to ensure stability across the newly streamlined platform.

17 changes.

The project significantly expanded its reach by introducing native clients for Wear OS, iOS (SwiftUI), and desktop, while adding Kotlin/Wasm support for the web. Concurrently, the backend was rewritten using Ktor, and the common layer adopted Koin for dependency injection and SQLDelight for local persistence, enabling richer data display and cross-platform consistency.

4 changes.

This period focused on expanding the application's cross-platform capabilities by introducing a new WinUI 3 desktop client and establishing the common UI infrastructure for iOS and other non-Windows platforms. Significant effort was also dedicated to implementing and refining features for visualizing the International Space Station's orbit, including debug tools and core view models.

The People In Space web application now runs on Kotlin/Wasm, providing a new execution target alongside existing platforms. This change introduces the Wasm-specific entry point (Main.kt) and UI layout, including the astronaut list and details view, along with the necessary HTML host page and Web Worker configuration for SQL.js database operations. Webpack configuration has been updated to handle Wasm asset copying and optimization, enabling users to access the app via a Wasm-based browser runtime.

compose-web · high confidence

Users can now view People in Space and ISS location information directly on their home screen via new Android widgets. The standard Glance-based widgets display a list of astronauts and a static map of the ISS position. Additionally, a new Remote Compose widget (available on Android 16+) provides an animated ISS orbit map, rendering the station's position and rotation in real-time. The app also introduces dedicated screens for the ISS position and detailed astronaut information, including their assigned spacecraft and nationality.

app/src/main/java/dev · high confidence

A new Swift executable package has been introduced to demonstrate interoperability with Kotlin Multiplatform. It includes a main entry point that initializes Koin, fetches a list of people using Kotlin-native coroutines via the KMPNativeCoroutinesAsync library, and streams real-time ISS position data, alongside a .gitignore file to manage build artifacts.

SwiftExecutablePackage · high confidence

New files were added to the common non-Windows module to provide the core UI and dependency-injection infrastructure for iOS and other non-Windows platforms. This includes the Koin configuration (Koin.kt) to wire up ViewModels and HTTP clients, the ISSPositionViewModel and PersonListViewModel to manage data flow, and the ISSPositionContent composable to display the ISS's current location on a map. Additionally, a localized string resource for 'ISS Position' was moved from the Android app module to this common location to support these new non-Windows UI components.

common/src/nonWindowsMain · high confidence

A new debug-only activity and utility module have been added to help visualize the International Space Station's orbit. The \RemoteComposeTestActivity\ provides a standalone view that fetches recent ISS positions, generates a map bitmap using osmdroid, and renders the orbit path as a red polyline. The underlying \GeoUtils\ utility handles the complex logic of calculating the optimal map center and zoom level to fit the orbit points, specifically accounting for the International Dateline crossing by splitting the path into segments.

app, app/src/debug · high confidence

A new Model Context Protocol (MCP) server has been added to the mcp-server module, exposing a 'get-people-in-space' tool that retrieves the current list of people in space. The server supports two communication modes: Server-Sent Events (SSE) on a configurable port (defaulting to 3001) and standard I/O (stdio), allowing clients to interact with the service via either real-time event streams or direct command-line interfaces.

mcp-server · high confidence

Users can now access People in Space on Wear OS devices with a dedicated app built on Jetpack Compose for Wear. The app features a list of astronauts, detailed profiles for each person, and an ISS map view, all navigable via swipe gestures and deep links (peopleinspace://). It also includes a Glance tile for quick access to the astronaut list. The UI follows Wear M3 guidelines and includes accessibility support, with image loading handled by Coil.

wearApp/src · high confidence

The backend service has been rewritten using Ktor 3.4.0, introducing a Swagger UI at /docs for API exploration and configuring CORS to allow standard HTTP methods. The server now exposes endpoints for retrieving the current list of astronauts (including nationality data for crew on the ISS and Tiangong) and the ISS position via an external API. Deployment is configured for Google App Engine using Java 21.

backend/src · high confidence

A new desktop application entry point has been added, providing a native UI to browse astronauts currently in space. The app features a split-pane layout with a scrollable list of crew members on the left and a details view on the right, utilizing a custom Material theme and Coil for image loading.

compose-desktop · high confidence

A new Windows desktop client built with WinUI 3 is now available, consuming the shared Kotlin Multiplatform data layer via a locally generated NuGet package. The app displays the current crew assignments and the live orbital position of the International Space Station, using the same data models and state flows as the other clients. It runs as an unpackaged, framework-dependent application on Windows 10 (x64) and requires the Windows App SDK 1.8 runtime.

common/src/mingwX64Main, windows · high confidence

The application now supports the WasmJs target by introducing platform-specific implementations for core infrastructure. A new Koin module configures the HTTP client to use the JavaScript engine and sets up SQLDelight with a WebWorker driver for database access, enabling data persistence in the browser environment. Additionally, the ISSMapView composable is implemented as an empty stub for WasmJs, allowing the UI layer to compile without errors while specific map rendering logic for this platform is deferred.

common/src/wasmJsMain · high confidence

The legacy PeopleInSpaceRepository class, which previously handled fetching astronaut data via a synchronous callback pattern and GlobalScope launches, has been removed from the shared codebase. This change eliminates the deprecated coroutine usage and callback-based API in favor of the modern flow-based or coroutine-native implementations integrated elsewhere in the application.

common/src/commonMain/kotlin/com/surrus/common/repository · high confidence

The \MainActivity\ and \PeopleInSpaceViewModel\ files in the \app/src/main/java/com/surrus/peopleinspace/ui\ package have been deleted. This removes the previous implementation that relied on \MutableLiveData\ for state management and early Jetpack Compose APIs (such as \androidx.ui\ and \+observe\), indicating a migration to a newer architecture or UI framework in this module.

app/src/main/java/com/surrus/peopleinspace/ui · high confidence

The legacy \PeopleInSpaceApi\ implementation, which used Ktor 1.x features (such as \JsonFeature\ and \KotlinxSerializer\) to fetch astronaut data from the Open Notify service, has been removed. This change eliminates the old HTTP client configuration and associated data models (\AstroResult\, \Assignment\) from the common remote layer, likely as part of a broader migration to newer Ktor APIs or a different data source.

common/src/commonMain/kotlin/com/surrus/common/remote · high confidence

The PeopleInSpaceSwiftUI Xcode project file has been deleted, indicating the removal of the iOS application's project configuration and build settings from the repository.

ios/PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI.xcodeproj · high confidence

The wearApp module now includes essential build configuration files to support release builds and performance testing. A .gitignore file has been added to exclude build artifacts, while proguard-rules.pro defines obfuscation and keep rules for the application code, AndroidX Wear libraries, OkHttp, Google Maps, Firebase Authentication, and Kotlin to ensure compatibility and security in minified releases. Additionally, benchmark-rules.pro is introduced to disable obfuscation specifically for benchmark builds, ensuring accurate performance measurements.

wearApp · high confidence

The dependency injection setup in the common module has been refactored to use Koin's annotation-based approach (e.g., @Module, @Single) and constructor injection. This change introduces platform-specific module implementations for iOS (using Darwin HTTP engine and Native SQLite) and JVM (using Java HTTP engine and in-memory JDBC SQLite), alongside a new JVM entry point that initializes Koin and fetches data. Additionally, a stub implementation for the ISS map view is provided for the JVM target.

common/src/iOSMain/kotlin/com/surrus/common/di, common/src/jvmMain · high confidence

The Android module now provides concrete implementations for platform-specific features previously handled by generic or deleted code. Dependency injection is configured via Koin to supply the Android application context, an Android-specific HTTP client engine, and an SQLite-backed database driver for the People In Space data. Additionally, the ISS location map view is implemented using OpenStreetMap and OsmDroid to display the ISS position marker, replacing the previous dispatcher-based coroutine handling which has been removed.

common/src/androidMain · high confidence

The local database schema for the PeopleInSpace module has been updated to store additional user profile details. The People table now includes columns for person image URLs, biographical text, and nationality, allowing the application to display richer profile information for each person.

common/src/commonMain/sqldelight · high confidence

The application's dependency injection has been migrated to Koin, utilizing the Koin compiler plugin and annotations (e.g., @Single) in the new \Dependencies.kt\, \AstroviewerApi.kt\, \PeopleInSpaceApi.kt\, and \PeopleInSpaceRepository.kt\ files. This change replaces the previous DI approach and introduces a new \AstroviewerApi\ to fetch ISS future orbit positions, enabling the display of an animated ISS orbit in the UI. Additionally, the repository now exposes \initialSyncCompleted\ state to fix the first-run loading state, ensuring the UI correctly distinguishes between initial loading and empty results.

common/src/commonMain/kotlin/dev · high confidence

The project now includes an Apache 2.0 license file and a Renovate configuration that explicitly disables automatic updates for the Android Gradle Plugin and Gradle wrapper to prevent sync failures with the locally installed Android Studio. The .gitignore has been expanded to cover Kotlin, Android, and Xcode build artifacts, while the README has been significantly updated to document the full multiplatform architecture (including Wear OS, Desktop, Web, and WinUI clients) and provide detailed build and deployment instructions.

(repo-wide) · high confidence

The Android-specific Application class (PeopleInSpaceApplication) that previously handled Koin dependency injection setup has been removed. This indicates a shift away from manual Koin initialization within the Application lifecycle, likely moving towards a different initialization strategy or framework integration within the app module.

app/src/main/java/com/surrus/peopleinspace · high confidence

The Android-specific Koin module (AppModule.kt) has been removed from the app source code. This change eliminates the local registration of the PeopleInSpaceViewModel and PeopleInSpaceRepository, indicating that these dependencies are now managed elsewhere, likely within the shared codebase or a different module, as part of the broader effort to move view models to shared code.

app/src/main/java/com/surrus/peopleinspace/di · high confidence

The CocoaPods-generated support files for the iOS app have been removed, including the acknowledgements markdown and plist, the dummy Objective-C source file, and the debug and release xcconfig files. This indicates that the project is no longer using CocoaPods to manage its dependencies.

ios/PeopleInSpaceSwiftUI/Pods/Target Support Files/Pods-PeopleInSpaceSwiftUI · high confidence

The \Pods.xcodeproj\ file, which is automatically generated by CocoaPods to manage dependencies and build configurations for the iOS app, has been deleted. This change indicates a shift in how the project manages its dependencies, likely moving away from CocoaPods or restructuring the build system, which will require developers to update their local environment or build scripts accordingly.

ios/PeopleInSpaceSwiftUI/Pods/Pods.xcodeproj · high confidence

The custom \ApplicationDispatcher\ and its iOS-specific \NsQueueDispatcher\ implementation have been removed from the common module. This change eliminates the manual bridging of Kotlin coroutines to the iOS main dispatch queue, aligning with the integration of native multithreaded coroutines.

common/src/commonMain/kotlin/com/surrus/common, common/src/iOSMain/kotlin/com/surrus/common · high confidence

The build configuration file (common.xcconfig) for the 'common' pod has been deleted. This file previously defined build settings such as framework search paths, Kotlin target definitions for iOS and macOS, and CocoaPods-specific variables. Its removal indicates that the 'common' module is no longer built or linked via CocoaPods in this iOS project, likely reflecting a shift in how this shared code is integrated or managed.

ios/PeopleInSpaceSwiftUI/Pods/Target Support Files/common · high confidence

The iOS workspace file and the associated CocoaPods configuration have been removed from the project. This eliminates the legacy workspace structure that referenced the main Xcode project and the Pods directory, indicating a shift away from the previous dependency management or build setup for the iOS application.

ios/PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI.xcworkspace · high confidence

The \contents.xcworkspacedata\ file for the PeopleInSpaceSwiftUI project has been deleted. This change removes the explicit workspace definition that previously referenced the \PeopleInSpaceSwiftUI.xcodeproj\, indicating a shift in how the iOS project is structured or managed within the development environment.

ios/PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI.xcodeproj/project.xcworkspace · high confidence

The \buildSrc\ module has removed the \Dependencies.kt\ file and its associated \.gitignore\, eliminating the centralized object-based dependency management (including versions for Kotlin, Koin, Ktor, and Android SDKs) that was previously maintained in this location. This change removes the local definition of build-time and runtime dependencies from the \buildSrc\ source tree, indicating a migration away from this specific centralized versioning approach within the build source directory.

buildSrc · high confidence

The local Xcode scheme management file for the user joreilly has been removed from the project repository. This change eliminates the user-specific scheme ordering hint, ensuring that the project's shared scheme configuration is not overridden by individual developer settings in version control.

ios/PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI.xcodeproj/xcuserdata · high confidence

The user-specific Xcode scheme files for the Pods project (specifically \Pods-PeopleInSpaceSwiftUI.xcscheme\, \common.xcscheme\, and the associated \xcschememanagement.plist\) have been deleted from the repository. This change removes local development configuration artifacts that were previously committed, ensuring that scheme settings are no longer shared or enforced across the team's local environments.

ios/PeopleInSpaceSwiftUI/Pods/Pods.xcodeproj/xcuserdata · high confidence

The People in Space iOS app has been rebuilt using SwiftUI, replacing the previous implementation. The main interface now uses a TabView to switch between a list of astronauts and the ISS position. The astronaut list displays updated details including nationality and a bio preview, with improved card styling. The ISS Position screen now integrates a native MapKit view to show the station's location, wired through a shared view model and a native view factory. Configuration has been modernized to use the iOS 15+ App Lifecycle (removing SceneDelegate and LaunchScreen storyboard references) and added an accent color asset.

PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI · high confidence

The PeopleInSpaceSwiftUI Xcode project has been moved from the nested ios/ directory to the top-level PeopleInSpaceSwiftUI folder. This structural change simplifies the repository layout and updates the workspace configuration to reflect the new location, ensuring the project builds correctly from the root level.

PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI.xcodeproj · high confidence

The ISS Position screen on iOS has been rewritten to use Compose Multiplatform instead of the previous native implementation. This change introduces a new \ISSMapView\ that renders a native MapKit view via \UIKitViewController\ interop, allowing the map to display the ISS position while keeping the rest of the UI in Compose. A \NativeViewFactory\ interface and \LocalNativeViewFactory\ composition local are added to bridge the native map creation with the Compose view model, ensuring the map updates correctly as the ISS position changes.

common/src/iOSMain/kotlin/com/surrus/common/ui · high confidence

The iOS application has removed the traditional UIKit AppDelegate and SceneDelegate files, along with the LaunchScreen storyboard, indicating a shift towards a SwiftUI-centric app lifecycle (likely using the @main entry point with a SwiftUI App struct). This change simplifies the app structure by eliminating the boilerplate code required for scene management in UIKit, allowing the SwiftUI views to manage the application's window and lifecycle directly.

ios/PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI · high confidence

1 commit adding/updating tests in common/src/nonWindowsTest; Added Compose UI tests for the People List screen; Added initial Maestro UI test for People in Space flow; Added unit tests for common repository and UI state logic; Removed default unit test file.

The project has transitioned from legacy Groovy build scripts and \buildSrc\ to a centralized Gradle Version Catalog (\libs.versions.toml\) and Kotlin DSL (\build.gradle.kts\). This change introduces type-safe project accessors and version aliases for all dependencies, including Kotlin 2.4.20, Compose Multiplatform 1.12.0, Koin 4.2.2, and Ktor 3.5.2. The migration also updates the Android Gradle Plugin to 9.1.1, upgrades the Android compile SDK to 37, and configures the backend to use Ktor 3.5.2 with Swagger support. Additionally, the iOS integration has shifted from CocoaPods to a Swift Package Manager setup, and the Windows client now targets .NET 10 with WinUI 3.

(dependencies) · high confidence

The project's Gradle wrapper has been updated from version 6.1-milestone-2 to 9.6.1. This change updates the distribution URL in the wrapper properties file to fetch the new Gradle binary, ensuring that builds use the newer Gradle release. Additionally, new configuration properties for network timeout, retries, and distribution URL validation have been added to the wrapper configuration.

gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 67 → 61 (-6.0)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 72 → 72 (-0.3)
• Architecture 96 → 100 (+3.8)
• Maturity 62 → 73 (+11.3)
• Readiness 66 → 44 (-21.7)
• Security 75 → 82 (+6.5)

• Inconsistent casing for string parameters representing a name. One uses lowercase name (standard C# convention for local variables/parameters), while the other uses PascalCase Name (typically reserved for properties).
• Inconsistent naming for the same parameter type in the same method Project. One overload uses the semantic name person (or people in the list overload), while another overload uses the generic type-name Name for a parameter of type Assignment (which represents a person in this domain context).

• Documentation: no installation or build instructions (README.md)
• Duplicated block (7 lines × 2) (PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI/ContentView.swift)
• MethodTooLong: PersonDetailsScreen.body (PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI/ContentView.swift)
• Off the main sequence: :common

• 22 commits — 21 feature/other, 1 fixes

• gradle/libs.versions.toml — 10 commits
• (root) — 3 commits
• .github/workflows — 2 commits
• backend/build.gradle.kts — 2 commits
• windows/WinUiApp — 2 commits
• PeopleInSpaceSwiftUI/PeopleInSpaceSwiftUI.xcodeproj — 1 commit
• SwiftExecutablePackage/Package.resolved — 1 commit
• common/src — 1 commit

• fix: revert gradle to 9.6.1 to avoid IntelliJ syncing issue + README update
• change: Update Gradle to v9.7.1 (#476)
• change: Update actions/setup-dotnet action to v6 (#521)
• change: Update actions/setup-java action to v6 (#522)
• change: Update coilCompose3 to v3.6.2 (#509)
• change: Update coilCompose3 to v3.6.3 (#526)
• change: Update dependency Microsoft.Windows.SDK.BuildTools to 10.0.28000.2705 (#513)
• change: Update dependency Microsoft.WindowsAppSDK to v2 (#523)
• change: Update dependency ch.qos.logback:logback-classic to v1.6.3 (#497)
• change: Update dependency co.touchlab:kermit to v2.2.0 (#518)
• change: Update dependency com.github.ben-manes.versions to v0.61.0 (#500)
• change: Update dependency com.github.ben-manes.versions to v0.62.0 (#519)
• change: Update dependency io.github.xxfast.kotlin.native.nuget to v0.6.0 (#520)
• change: Update dependency io.insert-koin.compiler.plugin to v1.2.1 (#502)
• change: Update dependency io.modelcontextprotocol:kotlin-sdk to v0.15.0 (#501)
• change: Update dependency org.jetbrains.compose to v1.12.0 (#510)
• change: Update dependency org.slf4j:slf4j-simple to v2.0.19 (#515)
• change: Update dependency rickclephas/KMP-NativeCoroutines to v1.0.6 (#516)
• change: Update ktor monorepo to v3.5.2 (#485)
• change: Update okhttp to v5.5.0 (#505)
• …and 2 more

• Containers 0 added · 0 removed · contexts 2 added · 0 removed · edges 2 added · 0 removed

• app
• common

• app → common
• wearApp → common

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

joreilly/PeopleInSpace was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.