Koin is a pragmatic, lightweight dependency injection framework for Kotlin and Kotlin Multiplatform. The core library (koin-core) provides a pure Kotlin DSL for defining modules with `single`, `factory`, `scoped`, and `viewModel` definitions, backed by a container (`Koin`, `Scope`, `InstanceRegistry`) that resolves dependencies in O(1) via `HashMap`. The framework supports multiplatform via expect/actual platform abstractions (logging, thread safety, ID generation) and integrates with Android (koin-android: Activity/Fragment scopes, ViewModel, WorkManager, Compose), Ktor (koin-ktor: server plugin, request scope, DI bridge), and Compose Multiplatform (koin-compose: composable application, scope/module lifecycle). Testing is first-class: koin-test provides module verification at build time, mock declaration, and JUnit4/JUnit5 integration. An optional Kotlin compiler plugin (koin-gradle-plugin) adds compile-time safety and auto-wiring, supplementing the classic DSL. The repository includes extensive examples (Android, Ktor, Compose, KMP) and performance benchmarks (JMH, kotlinx-benchmark). The codebase is well-structured with clear separation of concerns, platform-specific source sets, and a rich set of extension modules. Some APIs are marked experimental or deprecated and the compiler plugin requires Kotlin 2.3.20+, but overall the project is actively maintained, with a strong focus on backward compatibility and performance.
Kotest is a comprehensive, multiplatform testing framework for Kotlin, providing a rich assertion library, property-based testing, multiple spec styles (FunSpec, StringSpec, WordSpec, etc.), a modular test engine, and extensive extension system (Spring, Testcontainers, Allure, etc.). It includes IntelliJ IDEA plugin for gutter icons, test navigation, and run configurations, as well as Gradle plugin for build integration. The framework is well-architected with clean abstractions like the Matcher interface, Arb/Gen combinators, and test execution interceptors, though some deprecated APIs and experimental features indicate ongoing evolution.
xmlutil is a Kotlin Multiplatform XML library that provides three layers: a streaming pull-parser/writer abstraction (XmlReader/XmlWriter with a pure-Kotlin KtXmlReader and platform StAX/Android backends), a portable DOM Level 2 implementation with JVM/JS/Native/Wasm wrappers, and an XML serialization format for kotlinx.serialization (the XML.v1 codec with annotations such as @XmlSerialName, @XmlValue, @XmlPolyChildren and policy-based configuration). It is a library, not an application: there are no servers or CLIs, only published Maven artifacts (core, serialization, xmlschema, serialutil, testutil) plus examples, benchmarks, and a Gradle plugin used for building/publishing the library itself. It targets JVM, Android (deprecated module), JS, Native, and Wasm. The architecture is strictly modular: core/base holds platform-independent streaming, DOM, namespaces, and entity handling; core/jdk and core/android are platform backends; serialization implements the kotlinx.serialization format including type/descriptor caching, polymorphic parent handling, and compact-fragment support; xmlschema is a near-complete XML Schema 1.0/1.1 parser/resolver with a custom XPath expression engine and a purpose-built regex engine for XSD pattern facets; serialization-io and core/kxio bridge kotlinx-io sinks/sources; testutil ships cross-platform XML assertion helpers. The dominant data flow is: XML text -> streaming events (XmlReader) -> DOM or direct object deserialization, and the reverse for output, with XmlSerializationPolicy controlling naming, lists, maps, namespaces, and encoding/decoding behavior. The engineering depth is genuinely high: a hand-written XSD regex engine with Unicode decomposition and surrogate set classes, flat-array namespace stacks with O(1) depth operations, DTD/entity expansion logic, an LRU format cache with recursion detection, and binary-compatibility validation (API and klib .api files) on every build. Test coverage is extensive, including regression tests for dozens of numbered GitHub issues, a W3C XML Schema test-suite harness, and JVM benchmarks. The main weaknesses are an intentionally large experimental API surface (@ExperimentalXmlUtilApi), some boilerplate near-duplication in schema facet classes, and platform-source-set sprawl that multiplies maintenance cost. Maintenance is active: recent commits (Aug 2026), GitHub Actions CI (runTests, publish-snapshot, upload_release), zero Dependabot alerts, and modern tooling (Gradle version catalog, BOM, Gradle wrapper validation). Some legacy artifacts remain (stale .travis.yml, deprecated core-android and xmlserializable modules), but they are explicitly marked deprecated rather than silently rotting. Technical drift is low; the codebase deliberately tracks fast-moving kotlinx.serialization APIs and documents Kotlin compiler workarounds, indicating a maintained rather than abandoned project.
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.
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.
EhViewer is a high-performance Android client for browsing, reading, and downloading galleries from the E-Hentai / ExHentai image hosting sites. It is a modern fork of the classic EhViewer app, built entirely with Kotlin Multiplatform for shared logic and Jetpack Compose with Material Design 3 for the UI. The architecture is modular (app, core/common, core/data, core/ui, core/i18n) and leverages Rust via JNI for performance-critical HTML parsing and image processing (border detection, QR code detection, WebP animation). The app features a full-featured reader with multiple reading modes, a foreground download service with speed tracking, comprehensive offline support via Room/SQLite, and integration with GitHub releases for updates. The codebase is actively maintained, uses the latest Kotlin, Compose, and Ktor versions, and demonstrates strong engineering practices with clean abstractions, coroutine-based reactive state, and type-safe preferences. It is a dedicated application project with no data science or research 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.
Fuel is a Kotlin Multiplatform HTTP networking library built on kotlinx.coroutines, providing suspend-style HTTP verbs (GET, POST, PUT, PATCH, DELETE, HEAD, arbitrary methods) plus Server-Sent Events streaming across JVM, Apple (iOS/macOS), and WasmJS targets. The core fuel module uses an expect/actual split: a common HttpLoader interface and FuelBuilder are backed by OkHttp on JVM, NSURLSession on Apple, and the browser fetch API on WasmJS. A global Fuel object supports plugging in a custom loader or loader factory, and extension functions on String (httpGet(), httpPost(), etc.) provide concise request entry points. A FuelRouting interface lets applications model typed API endpoints as sealed classes. Four optional serialization modules — fuel-jackson-jvm, fuel-moshi-jvm, fuel-kotlinx-serialization, and fuel-forge-jvm — each add a small extension on HttpResponse (toJackson, toMoshi, toJson, toForge) that decodes the body and returns a Result from the companion Result library. The core response model is deliberately minimal: a mutable HttpResponse holding a status code, a kotlinx.io Source body stream, and headers. JVM request handling is semantically correct about HTTP (e.g., consulting OkHttp's HttpMethod.permitsRequestBody before attaching a body). The project is published as 3.0.0-alpha04, uses Kotlin 2.3 / Gradle 9.3 / OkHttp 5 alpha, and is actively maintained with CI, Renovate, Dependabot, and ktlint. JVM has solid unit coverage using MockWebServer for all verbs, routing, custom OkHttp configurations, and each serialization adapter. Apple and Wasm targets are implemented but largely untested outside manual samples, and the Apple SSE implementation is a naive full-body line splitter rather than true incremental streaming. Overall this is a clean, modern, well-organized library with a couple of genuinely reusable pieces (notably the Android-derived UriCodec port) and some pre-1.0 rough edges. This is a pure application/library repository, not a data 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.
Square Logcat is a lightweight Kotlin multiplatform logging library that provides a simple API for logging on Android and JVM platforms. The library wraps Android's android.util.Log class and offers a similar API for JVM environments. Key architectural decisions include inlined logging functions that avoid string evaluation when logging is disabled, automatic tag extraction from calling class names without stacktrace overhead, and support for multiple concurrent loggers with thread-safe management. The library uses kotlinx.atomicfu for thread-safe collections and follows a clean separation between the logging API (logcat function) and logger installation (LogcatLogger interface).
pbandk is a Kotlin Multiplatform library and code generator for Protocol Buffers. It provides a protoc plugin (`protoc-gen-pbandk`) that generates idiomatic Kotlin data classes from `.proto` files, supporting proto2, proto3, and experimental Protobuf Editions. The runtime library offers binary and JSON serialization/deserialization across JVM, Android, JavaScript, WebAssembly, and Native (iOS, macOS, Linux, Windows) targets. The architecture is a classic protobuf toolchain: `.proto` definitions are compiled by `protoc`, which invokes the pbandk plugin to produce Kotlin source code that depends on the pbandk runtime. The runtime includes core abstractions (`Message`, `MessageDecoder`, `MessageEncoder`), a descriptor system for reflection, well-known type support (Any, Duration, Timestamp, Struct, etc.), and configurable JSON encoding. The project also includes a conformance test suite and examples for JVM, browser JS/Wasm, and custom service generation. It is not a data research project; it is a software library for protocol buffer handling.
Loop Habit Tracker is a mature, open-source Android application for building and maintaining habits through daily check-ins, scoring, streaks, and detailed statistics. The system is architected as a Kotlin Multiplatform project with a shared core module (`uhabits-core`) containing all business logic, models, commands, and platform abstractions, and an Android-specific module (`uhabits-android`) providing the UI, widgets, notifications, and platform implementations. The core uses an MVP-like pattern with presenters, immutable state, and a command pattern for all habit mutations (create, edit, delete, archive, toggle checkmarks). Data is persisted locally in SQLite with a custom migration system supporting 25+ schema versions. The app features extensive home screen widgets (checkmark, score, streak, frequency, history, target), reminders with snooze, Tasker/Locale automation, CSV export, and import from other habit trackers (HabitBull, Rewire, Tickmate). External dependencies include AndroidX, Material Components, Ktor (for sync), AppIntro, and OpenCSV. The codebase demonstrates strong engineering practices: dependency injection via kotlin-inject, platform-agnostic canvas drawing for custom charts, a robust caching layer for list performance, and comprehensive test coverage including unit tests, instrumented UI tests, and snapshot-based rendering tests.
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.
Episteme is a modern, cross-platform e-book and document reader built with Kotlin Multiplatform and Compose Multiplatform. It supports a wide array of formats including EPUB, PDF, MOBI, audiobooks (M4B), FB2, DOCX, ODT, PPTX, and comic archives (CBZ/CBR). The app offers a rich reading experience with paginated and vertical scroll modes, text-to-speech, ink and text annotations, OPDS catalog browsing, cloud sync via Google Drive and Firestore, AI-powered summarization, and extensive customization (themes, fonts, brightness). The codebase is organized into a shared module containing core business logic, models, and policies, with platform-specific implementations for Android (native Compose, Room, WorkManager), iOS (Swift), and Desktop (Compose Desktop, Swing interop). The architecture follows a clean separation of concerns with expect/actual abstractions for platform services, making it a strong example of production-ready KMP application design.
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.
AutoDev is a multi-platform AI-powered coding assistant that integrates with IntelliJ IDEA and VS Code, and also runs as a standalone desktop app, CLI, web app, and mobile app. Its core engine is a Kotlin Multiplatform (KMP) agent framework that orchestrates LLM calls, tool execution (file I/O, shell, web fetch, MCP servers), and code generation/refactoring. The architecture is modular: `mpp-core` provides shared agent logic, tool schemas, linters, and document parsing; IDE-specific plugins (`mpp-idea`, `mpp-vscode`) deliver chat panels, inline completions, code review, and database integration; `mpp-ui` is a Compose Multiplatform frontend for desktop/CLI/mobile; `mpp-server` is a Ktor-based remote agent server; `xiuper-ui` implements a novel spec-driven UI DSL (NanoDSL) for rendering agent output as interactive components. The system supports multiple LLM providers (OpenAI, Anthropic, Google, GitHub Copilot, etc.), MCP protocol for tool integration, and A2A (agent-to-agent) communication. It includes a custom DSL (DevIns/Shire) for defining agent behaviors, completions, and variable resolution. While primarily an application, it includes data processing components like code graph parsing, document indexing, NLP tokenization, and heuristic scoring models, giving it a hybrid character. The codebase is large and actively developed, with frequent releases and a rich set of features, though some platform-specific implementations are stubs and there is moderate technical drift from deprecated APIs and naming inconsistencies.
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.