ESBMC (Efficient SMT-based Bounded Model Checker) is a mature, open-source formal verification tool that automatically detects or proves the absence of runtime errors in C, C++, Python, Java/Kotlin (via Jimple), CHERI, and Solidity programs. It parses source code using language-specific frontends (Clang for C/C++, CPython parser for Python, Soot for Java), converts programs into a common GOTO intermediate representation, and performs bounded symbolic execution with SMT solving (Z3, Bitwuzla, CVC5, Yices, etc.). The tool checks for assertions, memory safety (buffer overflows, null pointers, use-after-free), arithmetic overflows, concurrency races, and user-defined contracts (requires/ensures/assigns). It supports advanced verification techniques including k-induction, loop invariant synthesis, incremental BMC, and quantifier reasoning. The architecture is modular: frontends produce GOTO programs, which are then processed by a series of analysis passes (pointer analysis, value-set analysis, loop unrolling, contract enforcement) before being encoded into SMT formulas. The solver backend is pluggable, with support for interactive solvers and experimental one-shot solvers (Mallob, NeuroSym). The repository includes an extensive regression test suite with thousands of small, self-contained test cases organized by language and feature, many with paired passing/failing variants to ensure soundness. Operational models for C standard library functions, C++ STL, Python standard library (including numpy), and SystemC are bundled as source code for SMT translation. Key entry points include the main ESBMC binary (built from `src/esbmc/`), the Clang C/C++ frontend (`src/clang-c-frontend/`), the Python frontend (`src/python-frontend/`), and the solver interfaces (`src/solvers/`). The tool is actively used in research and industry, has won 43 awards at SV-COMP and Test-Comp, and is supported by multiple funding agencies. External dependencies include Boost (program_options, filesystem), Clang/LLVM, and several SMT solvers.
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.
NativeScript is a mature, cross-platform mobile application framework that enables developers to build native iOS, Android, and visionOS apps using JavaScript, TypeScript, or Angular. The repository is structured as a monorepo containing the core runtime (`@nativescript/core`) with platform-abstracted UI components, styling engine, data binding, and application lifecycle management; dual build toolchains (`@nativescript/vite` and `@nativescript/webpack5`) with Hot Module Replacement (HMR) support; platform type definitions (`@nativescript/types-ios`, `@nativescript/types-android`); and native widget libraries (Android Java, iOS Objective-C). The architecture is component-based: XML-declared UIs are parsed by a builder, instantiate native views, and styled via a custom CSS engine with selector matching, inheritance, and animations. An extensible property system with coercion, CSS properties, and change tracking drives reactivity. HMR infrastructure includes a Vite plugin that serves modules over WebSocket with framework-specific strategies (Angular, Vue, Solid, TypeScript). The codebase is heavily tested with unit tests (Vitest), platform-specific integration tests, and Appium E2E tests. Reusable design patterns include the observable data binding, property change origin tracking, platform-qualified file resolution, and CSS media query parsing. Notable technical drift risks include the coexistence of two build systems (webpack5 deprecated in favor of Vite), extensive platform-specific code duplication (`.android.ts`/`.ios.ts` pairs), and reliance on some deprecated iOS APIs in type declarations. Overall, it is a well-engineered framework with a large ecosystem and active development.
Neo-Store is a modern, feature-rich Android client for F-Droid and compatible open-source app repositories. Built with Kotlin and Jetpack Compose, it provides a full-featured app store experience: browsing apps by category, search, filtering, and sorting; managing multiple repositories with incremental index synchronization; downloading and installing APKs via multiple backends (root, Shizuku, session, legacy); tracking app updates; displaying detailed privacy information (permissions, trackers, anti-features) via integration with Exodus Privacy and VirusTotal; and visualizing download statistics. The architecture follows MVVM with Room for persistence, Koin for dependency injection, and WorkManager for background sync and download tasks. The codebase is well-structured with a clean separation of data, domain, and UI layers, though it contains some experimental API usage and extensive auto-generated icon files.
This repository contains an Android library for creating additive animations, where multiple animations can be combined by adding their values together rather than having later animations override earlier ones. The library provides a fluent API for animating View properties (position, size, rotation, alpha, etc.) and custom object properties. Key features include physics-based spring animations with configurable stiffness and damping, animation chaining with flexible timing controls, view visibility animations that automatically handle state transitions, and a sophisticated animation state system that determines whether to run animation start/end logic based on the current state of the target object. The implementation stands out for its physics-based spring solver (SpringSolver.kt) which provides an analytical solution to the damped harmonic oscillator equations, handling all damping regimes correctly. The RunningAnimationsManager provides intelligent state management for animations, eliminating common boilerplate for visibility and state-based animations. The library is actively maintained with recent updates, uses current AndroidX dependencies, and follows modern Android development practices with Kotlin coroutines and Java 17 compatibility.
PipelinR is a lightweight Java library implementing the mediator/pipeline pattern for command processing. It provides a type-safe way to send commands to handlers through a configurable pipeline of middleware, supporting cross-cutting concerns like logging, validation, and transactions. The library also implements notification (event publishing) with multiple handling strategies including synchronous, asynchronous, and parallel execution modes. With zero dependencies and a focus on simplicity, it aims to help developers follow SOLID principles by replacing monolithic service classes with focused handlers.
This repository is an IntelliJ Platform plugin that integrates ktlint, the Kotlin linter, into JetBrains IDEs. It runs ktlint automatically on Kotlin files, highlights violations in the editor, provides quick fixes, and supports custom rulesets and baseline files. The plugin is built as a Gradle multi-module project with a dedicated ktlint-lib module that bundles the ktlint engine, and a ktlint-plugin module containing the IntelliJ-specific integration. It uses the IntelliJ Platform Gradle Plugin, convention plugins in build-logic, and a set of shell scripts for release and IDE compatibility checks. Architecturally, the plugin is a standard IntelliJ plugin: it registers an external annotator for real-time diagnostics, a local inspection for batch analysis, and persistent settings components for application and project configuration. It caches baseline violations to avoid re-reporting known issues and loads external ruleset JARs at runtime. The build is automated with GitHub Actions for build verification, UI tests, IDE release checks, and Gradle wrapper updates. The code is written in Kotlin and follows IntelliJ plugin best practices, with JUnit4 tests and a release pipeline that generates plugin descriptions from the README.
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.
Phocid is a full-featured offline Android music player built with Jetpack Compose and Material3, targeting Android 11+. It serves as a modern replacement for Phonograph, offering extensive customization of themes, artwork colors, layouts, and playback behavior. The application manages a local music library by scanning MediaStore and optionally using JAudioTagger and OpusMetadataIo for advanced metadata extraction. It supports playback via Media3 ExoPlayer with custom shuffle, repeat, speed/pitch control, and a sleep timer. The UI includes a tabbed library view (tracks, albums, artists, genres, folders, playlists), a player screen with artwork, synced lyrics (LRC), and a queue, plus home screen widgets and Android Auto integration. Playlist management features M3U import/export with relative paths and bidirectional sync using file timestamps. The codebase is well-structured with clear separation of concerns: data layer (LibraryIndex, Playlist, Preferences), service layer (PlaybackService, PlayerManager), UI components (custom scrollbar, swipe-to-dismiss, carousel, dialogs), and utility modules (AsyncCache, SaveManager, StateFlow extensions). It includes unit tests for core logic (lyrics parsing, playlist I/O, search, sorting, caching) and uses Kotlinx Serialization for persistence with upgrade paths. The architecture follows a single-activity pattern with Compose navigation and a ViewModel-driven state management. While primarily an application, it contains reusable data engineering patterns such as generic persistence, concurrent caching, and locale-aware sorting that could be extracted for other projects.
BetterModel is a high-performance, server-side Minecraft plugin and mod (Bukkit/Paper/Fabric) that renders custom 3D models from BlockBench (.bbmodel) files using Minecraft's display entities. It automatically generates resource packs, supports keyframe and Molang-driven animations, per-player model visibility, hitboxes, mounting, player skin integration, and third-party compatibility (MythicMobs, Citizens, SkinsRestorer). The architecture is modular with a clean API/implementation split, platform abstraction, and version-specific NMS modules for multiple Minecraft versions (1.21.4 through 26.3). The codebase demonstrates strong engineering practices in packet bundling, animation interpolation, concurrency utilities, and event-driven design. However, it suffers from significant code duplication across NMS versions, minimal test coverage, and heavy reliance on Minecraft internals via reflection, which introduces maintenance fragility. It is actively maintained with frequent updates and a responsive issue tracker.
This is a high-quality Android sample application from Nordic Semiconductor that demonstrates Bluetooth Low Energy (BLE) connectivity using the Kotlin BLE Library. The app connects to a peripheral implementing the LED Button Service (LBS), allowing users to toggle an LED and detect button clicks and long presses. It features a modular architecture with separate modules for the device specification (transport-agnostic), BLE transport implementation, UI, and scanner. The app uses Jetpack Compose for UI, Hilt for dependency injection, Navigation 3 for navigation, and a foreground service for background operation. It includes both a native flavor for real BLE hardware and a mock flavor for testing without physical devices. The codebase is well-structured, follows modern Android best practices, and serves as a reference for building BLE apps with the Nordic BLE library.
Methanol is an extensible HTTP client library built on Java's java.net.http package. It provides core HTTP functionality enhanced with features like automatic decompression (gzip, deflate, Brotli), pluggable body adapters for JSON/XML/Protobuf, HTTP caching with multiple backends (memory, disk, Redis), request/response interceptors, retry mechanisms, progress tracking, and Kotlin DSL support. The library follows a modular architecture with separate modules for core functionality, format adapters, extensions, and testing. Key entry points include Methanol.Builder for client creation, MutableRequest for request building, and BodyAdapter for encoding/decoding. Data flows involve request interception, body encoding, HTTP exchange via java.net.http, response interception, body decoding, and optional caching/progress tracking. External dependencies vary by module: core requires only JDK 11+, while adapters depend on libraries like Jackson/Gson/Moshi, extensions on Redis Lettuce or native Brotli, and testing on JUnit5/MockWebServer.
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.
Gratatouille is a framework for building Gradle plugins using a functional programming approach. It processes Kotlin functions annotated with @GTask, @GPlugin, and @GExtension via KSP to generate complete Gradle plugin implementations including task classes, workers, entry points, and descriptor files. The framework enforces classloader isolation to prevent dependency conflicts and provides automatic build caching, parallel execution, and automatic task wiring. Generated code follows Gradle best practices with proper input/output annotations and up-to-date checks.
This is a GitHub Action that parses JaCoCo XML coverage reports and posts a formatted coverage summary as a comment on pull requests. It supports single and multi-module projects, aggregate reports, multiple counter types (INSTRUCTION, BRANCH, LINE, COMPLEXITY, METHOD), custom emojis, and comment update strategies. The action fetches the list of changed files from the PR via the GitHub API, computes overall and per-file coverage percentages, and renders a markdown table with pass/fail indicators based on configurable thresholds. The codebase is written in TypeScript, well-structured with clear separation of concerns (action orchestration, XML parsing, coverage computation, markdown rendering), and includes a comprehensive test suite with fixtures covering various report structures and edge cases.
This is the Shadowsocks Android client, a secure proxy/VPN application for circumventing internet censorship. It operates as a multi-module Android project with a core library providing the proxy engine, VPN service, and plugin management, plus separate mobile and TV UI modules. The application routes traffic through a remote SOCKS5 proxy, supporting multiple service modes (VPN, proxy, transproxy), per-app routing via ACL (Access Control List) rules, and native binaries (tun2socks, shadowsocks-rust) compiled via NDK or Rust. Key features include QR code import/export, subscription-based server list updates, and a plugin system that allows third-party native executables (e.g., v2ray, kcptun) to be integrated. The architecture follows Android best practices with Room for persistence, Coroutines for async work, and AIDL for inter-process communication between the UI and foreground services. The codebase is well-organized with extensive testing, CI/CD (CircleCI, GitHub Actions), and localization in over a dozen languages, but shows some technical drift with deprecated APIs and complex native build scripts.
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.
This is an Android application that turns a smartphone into an SMS/MMS gateway. It exposes a local REST API (Ktor-based HTTP server) for sending and receiving messages, supports cloud server integration via Firebase and Server-Sent Events, and provides webhook delivery, end-to-end encryption (RSA-OAEP + AES-GCM), and device key rotation. The architecture is modular: foreground services (SSE, ping, local server), WorkManager workers for background tasks (message sending, webhook queue processing, inbox upload, settings sync), a Room database for persistence, and Koin for dependency injection. The codebase is well-structured with event-driven communication via a custom EventBus, a validated state machine for message lifecycle, encrypted storage, and rich UI fragments. It supports SMS, MMS, and data SMS, with inbound message capture via broadcast receivers and content observers.
DUNE is a specialized Android TV client application for the Jellyfin media server ecosystem. It functions as a media consumption interface optimized for remote control navigation, featuring video/audio playback, library browsing, live TV (DVR) management, and extensive user customization. The architecture is a monolithic Android application with modularized internal structure (app, playback, preference modules), utilizing a hybrid UI approach that combines Jetpack Compose for modern screens (preferences, overlays) with Android Leanback widgets for traditional TV browsing. The codebase demonstrates strong separation of concerns, particularly in the playback layer which abstracts media rendering logic from the UI. It relies heavily on the Jellyfin SDK for API communication and ExoPlayer (Media3) for media rendering.
Config4k is a lightweight Kotlin library that wraps Typesafe Config (HOCON), providing seamless conversion between Config objects and Kotlin types. It offers extension functions `Config.extract<T>` and `Any.toConfig` for deserialization and serialization, supporting data classes, enums, collections, value classes, and a wide range of primitive and JDK types. The library integrates with kotlinx.serialization for HOCON format handling and includes a plugin system (CustomType interface) for extending supported types. It is well-tested, has CI/CD pipelines, and publishes to Maven Central. The architecture is modular with separate readers and serializers per type, making it extensible and maintainable.