100 Best Apps for Kotlin Developers
Kotlin development spans IDEs, frameworks, testing tools, and libraries. This first group covers foundational choices for many Kotlin workflows.
IntelliJ IDEA
IntelliJ IDEA provides code editing, debugging, refactoring, testing, and Kotlin-aware project navigation. It reduces time spent understanding large codebases through inspections, safe refactors, and intelligent code completion.
Android Studio
Android Studio is Google's IDE for creating, testing, profiling, and packaging Android applications with Kotlin. It centralizes Android device emulation, layout inspection, build tooling, and debugging in one development environment.
Kotlin Playground
Kotlin Playground lets developers write, run, and share Kotlin code snippets directly in a browser. It removes local setup friction when testing language features, teaching concepts, or sharing small examples.
Gradle
Gradle automates Kotlin project builds, dependency management, testing, packaging, and deployment-related tasks through configurable build scripts. It helps teams avoid manual build steps while keeping dependencies and repeatable workflows under version control.
Ktor
Ktor is a Kotlin framework for building asynchronous servers, HTTP clients, and networked applications. It gives backend developers Kotlin-native tools for handling routes, requests, serialization, and client communication.
Spring Boot
Spring Boot supports Kotlin for building standalone web services, APIs, data applications, and enterprise backends. It reduces infrastructure boilerplate with conventions, starters, and integrated support for common backend concerns.
Jetpack Compose
Jetpack Compose is Android's declarative UI toolkit for creating interfaces using Kotlin functions and state. It simplifies UI updates by replacing much imperative view manipulation with composable, state-driven interface code.
Compose Multiplatform
Compose Multiplatform enables Kotlin developers to create user interfaces for multiple supported platforms from shared code. It helps reduce duplicated interface work when products need consistent experiences across platform targets.
Kotlin Multiplatform
Kotlin Multiplatform supports sharing Kotlin code across platforms while retaining access to platform-specific APIs. It addresses duplicated business logic by allowing teams to share common code between application targets.
kotlinx.coroutines
kotlinx.coroutines provides structured concurrency primitives for asynchronous, nonblocking, and concurrent Kotlin programming. It makes asynchronous work easier to organize, cancel, and test than manually managed threads.
kotlinx.serialization
kotlinx.serialization converts Kotlin objects to and from formats such as JSON, CBOR, and ProtoBuf. It avoids repetitive parsing code when applications exchange structured data with services, files, or clients.
Dokka
Dokka generates documentation websites and reference material from Kotlin source code and documentation comments. It helps libraries keep API documentation close to implementation instead of maintaining separate manual references.
Detekt
Detekt statically analyzes Kotlin code for complexity, style issues, code smells, and maintainability concerns. It surfaces risky patterns early, helping teams maintain consistent code quality during ongoing development.
ktlint
ktlint checks and formats Kotlin source files according to a standardized Kotlin coding style. It eliminates many formatting debates and catches style inconsistencies before they reach code review.
MockK
MockK is a Kotlin-focused mocking library for creating test doubles and verifying interactions. It helps developers isolate units under test without hand-building fake implementations for every dependency.
Kotest
Kotest is a Kotlin testing framework offering assertions, test styles, property testing, and extensions. It gives teams expressive testing options when standard test structures feel too limited or repetitive.
JUnit 5
JUnit 5 provides a widely used testing platform and framework for unit and integration tests. It supplies familiar test lifecycle tools and ecosystem integration for validating Kotlin application behavior.
Retrofit
Retrofit turns HTTP APIs into typed Kotlin interfaces using annotations, converters, and request definitions. It reduces repetitive networking code when mobile or backend clients communicate with REST-style services.
OkHttp
OkHttp is an HTTP client library for sending requests, handling connections, and processing responses. It provides dependable low-level networking capabilities when applications need direct control over HTTP communication.
Room
Room is an Android persistence library that maps SQLite databases to Kotlin classes and queries. It makes local data storage safer by validating SQL queries and reducing database boilerplate.
Exposed
Exposed is a Kotlin SQL framework providing DSL and DAO approaches for database access. It lets backend teams write database interactions in Kotlin while retaining control over SQL-backed data.
SQLDelight
SQLDelight generates type-safe Kotlin APIs from SQL statements for local and multiplatform database access. It catches many query errors at build time while keeping database queries visible and maintainable.
Arrow
Arrow provides functional programming abstractions and utilities for Kotlin, including typed error-handling patterns. It helps developers model failures and complex transformations more explicitly in domain-heavy application code.
Koin
Koin is a Kotlin dependency injection framework that defines and resolves application components through modules. It reduces manual object wiring as projects grow and services acquire more dependencies.
Firebase
Firebase provides backend services including authentication, databases, cloud messaging, analytics, and application hosting. It helps small teams add common mobile backend capabilities without operating every supporting service themselves.
Maven
Maven builds JVM projects through declarative POM files, dependency management, plugins, and lifecycle phases. It reduces inconsistent local builds by standardizing dependency versions and repeatable project build steps.
GitHub
GitHub hosts Git repositories and provides pull requests, issue tracking, code review, and automation. It helps distributed teams coordinate Kotlin changes by centralizing reviews, discussions, and source history.
GitLab
GitLab combines Git repository hosting with merge requests, CI/CD pipelines, issues, and project planning. It simplifies managing code delivery when teams want repositories, pipelines, and tracking in one workspace.
Bitbucket
Bitbucket hosts Git repositories and integrates pull requests with Atlassian collaboration and CI/CD tools. It helps teams using Jira connect Kotlin code changes with tickets and review workflows.
GitHub Actions
GitHub Actions automates builds, tests, releases, and other workflows triggered by repository events. It removes repetitive release checks by running Kotlin project workflows automatically after pushes or pull requests.
Jenkins
Jenkins is an automation server for creating customizable continuous integration and continuous delivery pipelines. It helps teams automate complex build processes when hosted workflow services lack needed customization.
TeamCity
TeamCity is a continuous integration server that runs builds, tests, and deployment pipelines. It makes build failures easier to investigate through centralized build histories, logs, and test results.
SonarQube
SonarQube analyzes source code for bugs, vulnerabilities, code smells, and maintainability issues. It helps prevent quality regressions by flagging Kotlin code problems before they reach production.
Sentry
Sentry captures application errors, traces, and performance data from instrumented software environments. It shortens debugging time by grouping production exceptions and providing contextual event information.
Postman
Postman lets developers send, organize, test, and document requests to HTTP APIs. It speeds API troubleshooting by allowing developers to reproduce requests without building temporary client screens.
Insomnia
Insomnia is an API client for composing, sending, and organizing HTTP, GraphQL, and gRPC requests. It helps developers inspect service behavior quickly when backend endpoints need manual validation.
Swagger UI
Swagger UI renders OpenAPI definitions as interactive documentation for exploring and calling APIs. It reduces endpoint ambiguity by giving developers a browser interface for documented request formats.
OpenAPI Generator
OpenAPI Generator creates client libraries, server stubs, documentation, and configuration from OpenAPI specifications. It reduces repetitive integration code by generating typed Kotlin clients from a shared API contract.
WireMock
WireMock simulates HTTP services using configurable request matching, responses, delays, and fault scenarios. It enables reliable tests when external APIs are unavailable, costly, slow, or difficult to control.
Testcontainers
Testcontainers runs disposable containerized dependencies for integration tests through code-managed Docker environments. It reduces environment drift by testing Kotlin services against realistic database and messaging dependencies.
Espresso
Espresso is an Android testing framework for writing synchronized UI tests against application interfaces. It helps catch interface regressions by automating user interactions on Android application screens.
UI Automator
UI Automator automates Android device interfaces across apps and system-level user interface elements. It supports end-to-end device testing when workflows cross application boundaries or include system dialogs.
Robolectric
Robolectric runs Android unit tests on the JVM using simulated Android framework behavior. It accelerates feedback by testing Android components without requiring an emulator or physical device.
LeakCanary
LeakCanary detects retained objects and reports likely memory leaks in Android applications. It helps developers find memory retention problems before users encounter slowdowns or crashes.
Android Debug Bridge
Android Debug Bridge provides command-line communication with Android devices, emulators, and application processes. It streamlines device diagnosis by exposing logs, shell commands, installation, and debugging controls.
Charles Proxy
Charles Proxy captures and inspects network traffic between applications and internet services. It helps diagnose unexpected API behavior by revealing requests, responses, headers, and timing details.
Figma
Figma is a collaborative design tool for creating interface mockups, prototypes, and design systems. It reduces implementation guesswork by giving Kotlin developers shared access to approved interface specifications.
Jira
Jira tracks issues, projects, workflows, and team planning across software development efforts. It helps teams prioritize Kotlin work by organizing bugs, tasks, ownership, and delivery status.
Fastlane
Fastlane automates mobile build, signing, screenshot, beta distribution, and store release tasks. It reduces error-prone release chores by scripting recurring Android publishing and distribution workflows.
Appium
Appium automates mobile application testing through the WebDriver protocol across Android and iOS platforms. It supports shared end-to-end testing when teams need to validate workflows on multiple mobile platforms.
Visual Studio Code
Visual Studio Code provides a lightweight editor with extensions for Kotlin syntax, debugging, and project navigation. It reduces friction when developers need quick Kotlin edits without opening a full IDE.
YouTrack
YouTrack manages issues, agile boards, workflows, and project planning for software development teams. It helps teams organize Kotlin defects and feature work without losing ownership or priority context.
Linear
Linear provides issue tracking, project planning, and streamlined workflows for product and engineering teams. It helps small teams turn Kotlin development requests into clear, trackable implementation tasks.
Trello
Trello organizes work into visual boards, lists, and cards that teams can customize. It gives founders a simple way to track Kotlin tasks when formal project tooling feels excessive.
Slack
Slack provides channels, direct messaging, file sharing, and integrations for team communication. It centralizes development discussions so Kotlin-related decisions do not disappear across disconnected conversations.
Notion
Notion combines documents, databases, wikis, and project pages in a collaborative workspace. It helps teams keep Kotlin architecture notes and onboarding guidance accessible alongside planning materials.
Docker
Docker packages applications and dependencies into containers that run consistently across different environments. It reduces environment mismatch problems when Kotlin services behave differently on developers' machines and servers.
Kubernetes
Kubernetes orchestrates containerized applications by managing deployment, scaling, networking, and service availability. It helps teams operate multiple Kotlin services without manually coordinating container placement and recovery.
CircleCI
CircleCI automates build, test, and deployment pipelines using configuration stored with source code. It catches Kotlin integration failures earlier by running repeatable checks whenever code changes are submitted.
Travis CI
Travis CI runs automated builds and tests for projects connected to source code repositories. It helps maintainers verify Kotlin changes consistently instead of relying on manual pre-release testing.
Buildkite
Buildkite coordinates continuous integration pipelines while allowing teams to run build agents on their infrastructure. It gives teams control over specialized Kotlin build environments while centralizing pipeline orchestration.
Codecov
Codecov collects test coverage reports and displays coverage changes across commits and pull requests. It highlights untested Kotlin code paths so teams can focus testing effort on meaningful gaps.
Dependabot
Dependabot monitors dependencies and opens update pull requests for supported package ecosystems. It reduces the recurring work of finding outdated Kotlin libraries and preparing routine version updates.
Renovate
Renovate automates dependency update pull requests with configurable schedules, grouping, and version rules. It helps teams manage Gradle dependency maintenance without manually checking every library release.
Nexus Repository
Nexus Repository stores, proxies, and manages software components and package artifacts for development teams. It helps organizations control access to Kotlin build dependencies and retain internally published artifacts.
JFrog Artifactory
JFrog Artifactory manages binary artifacts, package repositories, build metadata, and dependency proxying. It reduces dependency distribution complexity when Kotlin teams publish and consume private libraries.
ProGuard
ProGuard shrinks, optimizes, and obfuscates Java and Android bytecode during application builds. It helps Android developers reduce application size and make compiled Kotlin code harder to inspect.
R8
R8 shrinks, optimizes, and obfuscates Android application code during the Android build process. It helps Kotlin Android teams limit APK or app bundle size without manual code removal.
Android Profiler
Android Profiler displays CPU, memory, network, and energy activity for running Android applications. It helps developers identify performance bottlenecks in Kotlin Android apps before users encounter slowdowns.
Perfetto
Perfetto records and analyzes system traces for performance investigation across Android and other platforms. It helps diagnose complex Kotlin app latency by showing timing across processes, threads, and system events.
Stetho
Stetho provides debugging access to Android application databases, network activity, and view hierarchies. It makes inspecting local Kotlin Android app state easier during development and troubleshooting.
Bugsnag
Bugsnag monitors application errors, groups crashes, and provides diagnostic context for software teams. It helps Kotlin developers prioritize production failures by showing affected errors and relevant debugging details.
Datadog
Datadog provides observability tools for metrics, logs, traces, dashboards, and service monitoring. It helps teams investigate Kotlin service health by correlating operational signals in one workspace.
New Relic
New Relic monitors applications and infrastructure through telemetry, dashboards, alerts, and transaction tracing. It helps developers locate slow Kotlin service transactions without manually combining logs and infrastructure data.
Google Play Console
Google Play Console lets Android developers publish apps, monitor releases, and review store performance information. It helps Kotlin Android teams manage production releases and investigate reported app quality issues.
Apollo Kotlin
Apollo Kotlin generates type-safe Kotlin clients for GraphQL APIs and manages normalized caching. It reduces fragile handwritten GraphQL parsing by generating models directly from schema and operations.
Coil
Coil loads, caches, and displays images efficiently in Android applications using Kotlin coroutines. It simplifies asynchronous image handling, preventing repetitive loading, caching, and lifecycle management code.
Glide
Glide is an Android image loading library with caching, transformations, and media decoding support. It helps developers avoid building custom image pipelines for remote images and resource-constrained screens.
Moshi
Moshi converts JSON data to and from Kotlin and Java objects using adapters. It addresses error-prone manual JSON parsing by mapping API payloads into structured application models.
Gson
Gson serializes Java and Kotlin-compatible objects to JSON and deserializes JSON into objects. It saves time when applications need straightforward JSON conversion without manually traversing JSON trees.
Jackson
Jackson provides JSON processing, data binding, and streaming APIs for JVM-based Kotlin applications. It helps teams handle varied JSON formats when simple object mapping requires configurable serialization behavior.
Realm Kotlin
Realm Kotlin provides an object-oriented database for Kotlin Multiplatform and Android applications. It reduces local data persistence complexity by avoiding much of the boilerplate around database queries.
ObjectBox
ObjectBox is an embedded object database offering local persistence and synchronization options for applications. It helps developers store application data locally without writing extensive SQL or object-mapping layers.
Supabase
Supabase provides backend services including PostgreSQL databases, authentication, storage, and realtime data features. It gives small teams managed backend building blocks instead of assembling common server infrastructure themselves.
AWS Amplify
AWS Amplify provides client libraries and tools for connecting apps to AWS cloud services. It helps Kotlin developers integrate authentication, storage, and APIs without hand-configuring every cloud connection.
RevenueCat
RevenueCat provides subscription infrastructure and SDKs for managing in-app purchase entitlements across platforms. It reduces the complexity of tracking subscription status and purchase access across mobile storefronts.
Hilt
Hilt is an Android dependency injection library built on Dagger and integrated with Android components. It simplifies wiring dependencies into activities, fragments, and view models with lifecycle-aware generated code.
Dagger
Dagger is a compile-time dependency injection framework for Java and Kotlin applications. It helps teams manage growing dependency graphs while catching many wiring errors during compilation.
Android Emulator
Android Emulator runs virtual Android devices for testing applications across device configurations and system versions. It lets developers test device-specific behavior without maintaining a physical device for every configuration.
Genymotion
Genymotion provides Android virtual devices for application testing on desktop and cloud environments. It offers alternative virtual device configurations when teams need broader Android testing environments quickly.
Maestro
Maestro is a mobile UI testing framework that defines end-to-end flows in simple YAML files. It makes repeatable mobile workflow testing more approachable than maintaining complex device automation scripts.
BrowserStack
BrowserStack provides cloud access to real devices and browsers for application and website testing. It helps distributed teams validate releases on devices they do not own or maintain locally.
Codemagic
Codemagic is a continuous integration and delivery service focused on mobile application build workflows. It reduces the operational burden of configuring and maintaining build infrastructure for mobile releases.
Android Lint
Android Lint analyzes Android project source code and resources for potential correctness and performance issues. It catches common Android-specific mistakes before release, reducing time spent diagnosing preventable implementation problems.
bundletool
bundletool builds, installs, and inspects Android App Bundles and generated APK sets. It helps developers verify bundle outputs and device-targeted APK behavior before publishing an Android release.
APK Analyzer
APK Analyzer inspects Android APK and App Bundle contents, sizes, files, and compiled resources. It helps identify oversized assets and dependencies when an Android application's download size grows unexpectedly.
Material Components for Android
Material Components for Android provides reusable UI widgets implementing Google's Material Design system. It speeds consistent interface construction by supplying maintained components instead of custom-building common controls.
Accompanist
Accompanist offers supplementary libraries for Jetpack Compose, including navigation and UI utility integrations. It fills practical Compose gaps when developers need common integrations not included in core libraries.
Lottie
Lottie renders animations exported from Adobe After Effects in mobile, web, and desktop applications. It enables polished motion design without developers manually recreating complex animations frame by frame.
Snyk
Snyk scans application dependencies and code for known vulnerabilities and security issues. It helps teams identify risky libraries early, before vulnerable dependencies reach production application builds.
These tools form a useful starting stack; the right combination depends on your platform, architecture, and team workflow.