Suwayomi-JUI is a multiplatform manga reader application built with Kotlin Multiplatform, targeting Android, Desktop, and iOS. It functions as a client for the Suwayomi-Server backend, communicating via GraphQL (Apollo) and REST (Ktor) to manage a personal manga library, download content for offline reading, and provide a customizable reading experience. The architecture follows a clean layered structure: core utilities, data layer (repositories and network clients), domain layer (business logic and use cases), and presentation layer (UI with Jetpack Compose/SwiftUI). Key features include library management with categorization, extension/plugin support, download queue management, reading interface with various navigation modes, backup/restore functionality, and comprehensive settings. The application employs dependency injection via custom annotations, reactive programming with Kotlin Flows and coroutines, and a cross-platform preference storage system. It is actively maintained with recent commits and demonstrates strong engineering practices in modularity and platform abstraction.
Kottie is a Compose Multiplatform library for rendering Lottie animations across Android, iOS, JVM, JS, and WebAssembly targets. It provides a unified API to load animations from URLs, files, or JSON strings and control playback via Compose's state management system. The library uses Kotlin Multiplatform's expect/actual pattern to abstract platform-specific Lottie implementations (Airbnb Lottie for native mobile, Skottie for web/Wasm) while offering idiomatic Compose interfaces. Sample applications demonstrate cross-platform usage, showcasing loading animations from local resources, remote URLs, and inline JSON with proper state handling for loading, success, and error conditions. The architecture separates concerns effectively: commonMain defines the API contracts (KottieCompositionSpec, RememberKottieComposition, AnimateKottieCompositionAsState, KottieAnimation), while platform-specific source sets implement the actuals using native Lottie runtimes. Key patterns include expect/actual for asynchronous resource loading with state management (RememberKottieComposition) and animation state hoisting (AnimateKottieCompositionAsState), both demonstrating reusable, non-boilerplate solutions for cross-platform resource-intensive components. The library integrates smoothly with Compose's lifecycle via LaunchedEffect and remember, ensuring proper disposal of animations. Maintenance is active with recent commits (2026-03-09) and CI/CD pipelines for building and code style checks. Technical drift is low due to modern Gradle version catalogs, up-to-date dependencies (e.g., Lottie-compose 6.7.1), and adherence to current Compose Multiplatform practices. The codebase avoids framework lock-in by isolating platform differences behind well-defined expect/actual interfaces, making the core patterns highly reusable for similar cross-platform resource loading scenarios.
This is a Kotlin Multiplatform application that provides a movie and TV show browsing experience across Android, iOS, Desktop, and Web platforms. The app fetches data from The Movie Database (TMDB) API and displays content including now playing movies, popular/top-rated/upcoming movies and TV shows, celebrity information, and search functionality. It follows MVVM architecture with Clean Architecture principles, using Koin for dependency injection, Kotlin Coroutines for asynchronous operations, Ktor for networking, and Compose Multiplatform for the UI layer. The application includes features like favorite management with local storage, genre filtering, and detailed views for movies, TV shows, and celebrities.
Camposer is a Kotlin Multiplatform camera library that provides a unified Compose Multiplatform API for camera functionality on Android (via CameraX) and iOS (via AVFoundation). It offers camera preview, photo capture, video recording, flash/torch control, zoom, tap-to-focus, exposure compensation, mirror mode, multi-lens selection, video stabilization, and image analysis (including barcode/QR scanning via the optional code-scanner module). The library is published on Maven Central and includes sample apps demonstrating both Android-only and cross-platform usage. The architecture follows a clean separation of concerns with an internal engine/applier layer: `CameraState` holds reactive state flows for all configurable properties, and platform-specific appliers (`PreviewApplier`, `VideoApplier`, etc.) write changes to the underlying hardware when the state changes. The public API exposes `CameraPreview` composable, `CameraSession` for state/info access, and `CameraController` for capture commands. The codebase is well-structured with expect/actual pattern, version catalogs, ABI validation, and extensive test infrastructure (unit tests, device tests, iOS tests). It is a well-crafted, actively maintained library with high reusability potential.
GKD is an open-source Android application that automates UI interactions, primarily to skip ads, auto-confirm dialogs, and perform custom click actions. It operates as an accessibility service, using a custom selector language (similar to CSS) to match UI nodes and execute actions defined in remote subscription rules. The app is built with Kotlin and Jetpack Compose, leveraging Room for local persistence, Ktor for HTTP, and Coroutines/Flow for reactive state management. It also integrates with Shizuku for privileged operations like input injection and screenshot capture. The architecture is modular: the main `gkd-app` module contains the UI, services, and rule engine; `gkd-selector` is a Kotlin Multiplatform library for parsing and matching the custom selector syntax; `gkd-db` provides a multiplatform database layer; and `gkd-hidden-api` contains stubs for Android hidden APIs used for automation. Key entry points include the accessibility service (`A11yService`), the subscription repository (`SubscriptionRepository`), and the snapshot capture system. Data flows involve downloading subscription rules, parsing them into internal representations, matching against accessibility node trees, and executing actions (click, swipe, etc.). External dependencies include AndroidX libraries, Ktor, Kotlin Serialization, Coil, and the Shizuku privilege library. The codebase demonstrates strong engineering practices with extensive unit tests, a well-defined selector engine, and reusable patterns like `Loadable` for async state and `MutexState` for concurrency. However, it relies heavily on hidden Android APIs and a custom DSL, which introduces maintenance risk. Overall, it is a high-quality, actively maintained project with significant reuse potential in its selector engine and utility components.
ImagePickerKMP is a Kotlin Multiplatform library (not a standalone application) that delivers production-grade media picking and barcode scanning capabilities for Android, iOS, JVM desktop, and web/JS/Wasm targets. The photo module (imagepickerkmp-photo) provides camera capture, gallery selection, image cropping, EXIF extraction with GPS redaction, configurable compression (LOW/MEDIUM/HIGH), and permission-request UI, all driven through a Compose Multiplatform API centered on rememberImagePickerKMP(). The scanner module (imagepickerkmp-scanner) provides continuous barcode/QR scanning with auto-zoom, distance warnings, batch mode, phantom-code suppression, and enterprise inactivity overlays, using ML Kit on Android and AVFoundation/Vision on iOS. A shared imagepicker-core module abstracts permissions, filesystem access, URI handling, language detection, and logging across platforms via the Kotlin expect/actual mechanism. The library is distributed as versioned Maven artifacts with a published JS bundle for web integration. Architecturally, the codebase is a modular multi-artifact Gradle project: imagepicker-core (infrastructure), imagepickerkmp-photo, and imagepickerkmp-scanner, with each module enforcing dependency boundaries (the scanner module explicitly prohibits depending on the photo module). Its design leans on config-driven API design (large nested data classes such as ImagePickerKMPConfig and ScannerBehaviorConfig with runtime validation), observable state holders (sealed Idle/Loading/Success/Dismissed/Error states backed by Compose mutableStateOf), and event-driven scanner orchestration. Platform-specific behavior is cleanly isolated through expect/actual: Android uses CameraX, ActivityResultContracts, and ExifInterface; iOS uses UIImagePickerController, PHPicker, PhotosUI, and CoreGraphics; desktop/web use file choosers or documented no-op stubs where camera hardware is unavailable. Localization spans 14 languages via YAML translation files and the i18nkonfig plugin, and CI (GitHub Actions) runs detekt static analysis, Kover coverage verification with a 90% line minimum, unit tests across commonTest/androidUnitTest/iosTest, and publishes coverage to Codecov. Maintenance is active: a recent commit history on the develop branch, one open issue, zero Dependabot alerts, and continuously updated Kotlin 2.x / Compose Multiplatform versions indicate steady upkeep. Known rough edges include intentionally blank PlatformPrewarm files, crop implementation stubs on JS/WASM, a handful of placeholder tests asserting true, duplicated permission-handling logic across photo/scanner modules, and a potentially stale build-and-bundle.sh referencing an old JS build path. Overall, this is a well-crafted, professionally engineered KMP library with genuinely reusable cross-platform abstractions and strong test discipline; it is a solid reference for Kotlin Multiplatform architecture and Compose-based camera/scanning UX.
Roborazzi is a Kotlin-based visual regression testing framework for Android, Compose Multiplatform (Desktop, iOS), and pure JVM. It integrates with Robolectric to capture screenshots of UI components in unit tests, compares them against golden images, and generates detailed reports (HTML, JSON, PR comments). The framework includes a Gradle plugin that creates record/verify/compare tasks, a JUnit rule for automatic capture, support for GIF/APNG/video recording, UI tree dumps, accessibility checks (via ATF), and experimental AI-powered image assertions (Gemini, OpenAI). It also auto-generates screenshot tests from Compose `@Preview` annotations for both Robolectric and Desktop targets. The architecture is modular: a core library with platform-specific implementations for Android, Desktop, and iOS; a painter module for image encoding/decoding; and separate modules for Compose integration, JUnit rules, preview scanning, and an IntelliJ/Android Studio plugin. The codebase is actively maintained, well-documented, and employs modern Kotlin patterns (KMP, Gradle Configuration Cache, BuildService). It is not a data research project.
FeedFlow is a cross-platform RSS feed reader built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, macOS, Windows, and Linux. It provides a rich reading experience with customizable layouts, reader mode with article extraction, offline content prefetching, and OPML/CSV import/export. The application emphasizes reliability through extensive unit testing, Maestro-based E2E tests for both mobile platforms, and a sophisticated cloud synchronization system supporting Dropbox, Google Drive, iCloud, FreshRSS, Miniflux, Feedbin, and BazQux. The architecture follows MVVM with clean separation of concerns (domain, data, presentation layers), uses Koin for dependency injection, SQLDelight for local persistence, and Ktor for networking. Platform-specific adaptations exist for background sync (Android WorkManager, iOS background tasks), widget support, and UI components (Compose Multiplatform for Android/Desktop, SwiftUI for iOS). The codebase demonstrates high craftsmanship with modular design, reusable abstractions (DataResult, content direction detection, image extraction, HTTP caching), and thorough test coverage including cloud sync conflict scenarios.
Rush is a cross-platform lyrics application built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, and Desktop (JVM). Its primary function is to search for, display, and share synced lyrics (line-synced and syllable-synced) from multiple sources including LrcLib, Genius, and a custom LyricsPlus API. The app integrates with the system's media playback to auto-detect the currently playing song and fetch matching lyrics. Notable features include romanization of lyrics for non-Latin scripts (Japanese, Korean, Hindi, Punjabi, Cyrillic) via a dedicated Android library, customizable visualizers (wave, gradient, hypnotic) for lyrics backgrounds, and a variety of share card styles (Spotify, Rushed, Brat, etc.). The architecture follows MVVM with Koin for dependency injection, Room for local persistence, DataStore for preferences, and Ktor for networking. The codebase is well-modularized with shared core, logic, and UI modules, though significant parts of iOS and Desktop support remain stubbed or incomplete.
This repository provides a full port of AndroidX ConstraintLayout and MotionLayout for Compose Multiplatform, enabling declarative, constraint-based layouts and keyframe animations across Android, iOS, Desktop, macOS, and Web (Wasm). The library is published as `tech.annexflow.compose:constraintlayout-compose-multiplatform` and includes a complete Kotlin Multiplatform implementation of the core constraint solver, motion engine, JSON5 parser, and Compose DSL. It supports both inline DSL and JSON-based constraint definitions, with experimental MotionLayout for animated transitions between constraint sets, including swipe gestures, keyframes, and custom easing curves. Architecturally, the project is split into a `compose` module containing the Compose-specific composables (`ConstraintLayout`, `MotionLayout`, `ConstraintSet`, `Transition`) and a `core` module that houses the platform-agnostic constraint solving engine (`LinearSystem`, `SolverVariable`, `ConstraintWidget`), motion interpolation (`CurveFit`, `Easing`, `StopLogicEngine`), and a custom JSON5 parser (`CLParser`). The sample app demonstrates various use cases such as collapsible toolbars, carousels, puzzle layouts, and swipe-driven transitions. The codebase is well-tested with extensive unit tests for both the core engine and Compose integration, and includes CI pipelines for building and validation. The library is actively maintained with recent commits and responsive issue triage. While it is a port of an AndroidX library, it has been adapted for multiplatform use with platform-specific expect/actual declarations for logging, weak references, and debug rendering. The code exhibits high craftsmanship in areas like the custom linear solver, motion interpolation algorithms, and the JSON parser, making it a valuable resource for developers needing advanced layout and animation capabilities in Compose Multiplatform projects.
FareBot is a Kotlin Multiplatform (KMP) application designed to read, parse, and analyze contactless transit smart cards (NFC/RFID). It targets Android, iOS, Desktop (JVM), and Web (Wasm), utilizing Jetpack Compose Multiplatform for the UI layer. The core functionality involves interacting with NFC hardware (Android NFC, PC/SC, CoreNFC) or external devices (Flipper Zero, PN533 USB readers) to extract raw card data. This data is then processed through a layered architecture of protocol readers (MIFARE Classic, DESFire, FeliCa, ISO7816) and transit-specific factories (EN1545, Calypso, proprietary formats) to display balances, trip history, and card identity. The architecture relies heavily on the Factory pattern to support hundreds of global transit systems without modifying core logic. It uses SQLDelight for local persistence of card dumps and keys, and Metro for dependency injection. The codebase demonstrates significant craftsmanship in reverse-engineering proprietary transit protocols, handling complex binary formats, bit-level parsing, and currency normalization across different regions. Hardware abstraction layers (`CardTransceiver`, `FlipperTransport`) allow the same core logic to run across diverse platforms and devices. While the application is actively maintained (last commit 2026-03-22), it faces technical drift risks due to its reliance on experimental Web APIs (WebUSB/WebBluetooth), cutting-edge Gradle versions (9.3.1), and the inherent fragility of reverse-engineered transit protocols. The project is a robust example of cross-platform hardware interaction and data parsing, suitable for engineers interested in NFC protocols, KMP architecture, and hardware abstraction.
SimpMusic is a production-grade Kotlin Multiplatform music player for Android and desktop (JVM) that streams from YouTube Music's undocumented backend. The codebase is organized around a shared Compose Multiplatform UI module (composeApp), Android entry points (androidApp), a desktop entry point (desktopApp), and optional feature modules for Google Cast, Last.fm scrobbling, and crash reporting. A separately referenced core submodule supplies domain and media-service logic. Internally it uses MVVM with Koin dependency injection, Repository interfaces backed by Room entities and DataStore, StateFlow-based ViewModels, and a large custom Compose component library covering home feed, library management, playlist sync, fullscreen player, lyrics, equalizer, podcasts, Android home-screen widgets, and a desktop mini-player. The app is shipped as a packaged consumer application with Play Store metadata, GitHub Actions, fastlane changelogs, and build variants that swap real integrations for empty stubs in FOSS builds.
This repository is a Kotlin Multiplatform (KMP) library collection designed for rendering rich text and Markdown within Compose applications on Android and Desktop. It consists of several modular artifacts: `richtext-ui` (core UI composables), `richtext-markdown` (AST-based rendering), `richtext-commonmark` (CommonMark parser integration), and theme-specific wrappers (`richtext-ui-material`, `richtext-ui-material3`). The architecture relies on a custom Abstract Syntax Tree (AST) representation of Markdown content, which is traversed recursively to emit Compose composables. While the codebase demonstrates strong engineering practices, particularly in handling deep nesting and large documents, the README explicitly warns that the project is experimental, lacks tests, and has an unclear roadmap. This makes it suitable for prototyping or internal tools but potentially risky for production-critical applications without significant validation.