The Kotlin world, assembled weekly, for Android engineers.
6 chapters · ordered by topic score · About & ContributingThe Kotlin world, assembled weekly, for Android engineers.
6 chapters · ordered by topic score · About & ContributingExplains Kotlin's by-keyword delegation for interfaces (auto-generated forwarding methods) and properties (lazy, observable, vetoable, map-backed, and custom getValue/setValue delegates). Connects the pattern to everyday Android usage like viewModels(), navArgs(), and mutableStateOf via remember.
26 stories
17 stories
19 stories
5 stories
4 stories
4 stories
4 stories
1 stories
1 stories
1 stories
You can either hang out in the Android Loop or the HURD loop.
Explains Kotlin's by-keyword delegation for interfaces (auto-generated forwarding methods) and properties (lazy, observable, vetoable, map-backed, and custom getValue/setValue delegates). Connects the pattern to everyday Android usage like viewModels(), navArgs(), and mutableStateOf via remember.
An introductory tour of Kotlin data classes explaining the auto-generated equals(), hashCode(), toString(), copy(), and componentN() functions, with Android examples spanning Retrofit response models, Room entities, and Compose/MVI UI state updated via copy().
Beginner walkthrough of Kotlin sealed classes and sealed interfaces, showing how to model restricted state hierarchies (Loading/Success/Error) for exhaustive when-expressions instead of enums or raw strings. Covers real Android patterns for ViewModel UI state, API results, navigation destinations, and Compose rendering in MVVM/MVI style.
Walks through headline Kotlin 2.4.0 changes: experimental collection literals using bracket syntax, context parameters graduating to stable with explicit-argument disambiguation, new isSorted()-family stdlib checks, and kotlin.uuid.Uuid reaching stable for cross-platform IDs. Framed as comedic dialogue but covers real compiler flags and APIs.
JetBrains open-sourced KotlinLLM, an IntelliJ plugin letting Kotlin/JVM code call asLlm/mockLlm 'Smart macros' whose generated bodies persist as ordinary, reviewable Kotlin source rather than hitting an LLM every call. Evaluated on Spring Petclinic and a GitHub issue-triage prototype (~89% recall), it aims to make runtime LLM delegation explicit and testable.
Walks through how suspend functions compile into continuation-passing state machines, using decompiled bytecode to show why coroutines are cheaper than OS threads. Covers CoroutineScope, Job vs SupervisorJob, launch vs async/await exception timing, and the four standard Dispatchers.
Explains why Kotlin uses Any instead of java.lang.Object as its root type: platform-agnostic design for JVM/JS/Native, dropping JVM-only methods like wait()/notify(), a non-nullable default (Any? for nullable), and compiler mapping of Any to Object in JVM bytecode for zero-overhead Java interop.
Independent Kotlin/Python project pairing an Android app with a Windows tray tool that converts Banglish (Bengali written in Roman script) to Bengali or English via Groq's free llama-3.3-70b-versatile API. The Android client is plain Kotlin calling the REST endpoint directly through OkHttp.
A Kotlin Academy newsletter issue explaining why GlobalScope causes memory leaks and poor testability compared to structured scopes like viewModelScope, covering ConcurrentHashMap and its unsynchronized extension functions like getOrPut, and clarifying that Compose modifiers act as ordered decorators, not parameters.
Walks through Kotlin's four visibility modifiers—public, private, protected, and internal—using a bank-account example, then maps each onto real Android patterns like repositories, singletons, and private constructors paired with companion-object factories.
A walkthrough of building an MCP server in Kotlin using the stdio transport, warning that any stray println or logging framework output corrupts JSON-RPC framing; the fix captures System.out before Logback initializes and redirects normal output to stderr.
A guide to Kotlin's coroutine builders (launch, async, runBlocking, withContext, coroutineScope, supervisorScope), covering their return types, start modes (including CoroutineStart.LAZY), and the key difference that launch throws exceptions eagerly while async defers them until await().
Beginner guide to Kotlin enum classes covering constructor properties, per-constant method overrides, built-in name/ordinal, the entries iteration API, and valueOf() string parsing. Closes with guidance on choosing enums for fixed constant sets versus sealed classes when states carry different data.
A short beginner explainer, written in Burmese, on Kotlin's null safety system: nullable type syntax with the question-mark suffix, the compile-time distinction between String and String?, and using the safe call operator to access members of nullable variables.
Walks through Kotlin's inline, noinline, and crossinline modifiers with bytecode-level before/after comparisons, showing how inlining avoids lambda allocations, enables non-local returns, and pairs with reified type parameters to bypass JVM type erasure.
An open-source Kotlin live wallpaper that renders a real-time double-pendulum chaos simulation using Hamiltonian dynamics and Runge-Kutta integration instead of looping video effects. Free on Play Store with source on GitHub, no network access or tracking.
Explains why Kotlin has no static keyword and how object declarations, companion objects, and the singleton pattern replace it, with Android examples such as a shared Retrofit client, a session manager, factory methods, and companion objects implementing interfaces.
Part 4 of a Kotlin Coroutines series introduces Flow as a cold asynchronous stream, contrasting a suspend function's single return with continuous emission via emit, collect, and operators like filter and map. Also distinguishes hot flows: SharedFlow and StateFlow.
Starting with AGP 9.2.0, R8 rewrites kotlinx.atomicfu's Atomic*FieldUpdater calls into Unsafe-based operations, cutting the reflection overhead that made compareAndSet ~2.7x slower than java.util.concurrent.atomic, yielding up to 2x faster coroutine launch and cancellation on Android.
Contrasts coroutineScope, where one child's failure cancels all its siblings, with supervisorScope, where failures stay isolated, using batch-upload versus dashboard-widget examples. Notes both only enforce structured concurrency locally and won't fix leaks if launched from GlobalScope or an unbound scope.
Explains that Kotlin coroutines are cooperative rather than preemptive: without a suspension point like yield() or delay(), a busy loop can monopolize a dispatcher's worker thread and starve other coroutines. Highlights why explicit suspension is required to avoid CPU starvation and stalled cancellation.
Explains Kotlin's CoroutineContext: how Job, Dispatcher, CoroutineName, and CoroutineExceptionHandler combine via the + operator, how child coroutines inherit and override parent context, and how withContext temporarily swaps dispatchers. A practical reference for reasoning about coroutine execution and cancellation.
I honestly didn't think you could even USE emoji in variable names. Or that there were so many different crying ones.
Google marks five years since Jetpack Compose 1.0, now used in over 68% of the top 1,000 Android apps, tracing its evolution from basic layouts to Compose for TV, Wear OS, Glance, and adaptive APIs like FlexBox and Grid. Confirms a Compose-first direction as the Views toolkit enters maintenance mode.
Fourth part of a series comparing Android Views, Jetpack Compose and Flutter by how many trees each uses to track configuration, identity and behavior: Views use one object for all three, Compose splits a slot-table bookkeeping structure from the LayoutNode tree, and Flutter separates Widgets, Elements and RenderObjects into three. Clarifies why Compose sits inside a single classic Android View for the final render pass.
Explains Compose Runtime's new retain API, which keeps plain Kotlin objects alive across configuration changes without extending ViewModel or any Android lifecycle class. Compares it against remember, rememberSaveable and ViewModel, arguing it suits reusable, framework-independent, multiplatform-friendly state holders but doesn't replace ViewModel features like viewModelScope, SavedStateHandle or Hilt integration.
Recounts pitfalls from a first production Jetpack Compose migration: picking screens whose data layer stayed tangled with legacy Fragments and ViewModels, plus imperative setContent calls that bypassed recomposition. Fixes shown include one observable ViewModel state collected via collectAsStateWithLifecycle and hoisting lambdas to cut unnecessary recomposition.
Indie developer account of rebuilding a flashlight app from scratch in Jetpack Compose with Material 3 and targetSdk 36 after losing the original source. Covers a rhythm-recording strobe editor, seizure-safety warnings, widget/tile shortcuts, and 16-language localization.
Shows how to use Compose's snapshotFlow to bridge internal Compose State (like scroll offsets or Pager position) into a Kotlin Flow for reliable UI testing, replacing flaky Thread.sleep()/polling with composeTestRule.waitUntil observing state that the Semantics Tree can't reach.
Walks through two Jetpack Compose animation techniques: a reusable shimmer Modifier built on an infinite gradient transition for loading skeletons, and SharedTransitionLayout-based hero image transitions between a list and detail screen keyed by URL.
Walks through Compose state fundamentals: mutableStateOf, remember, and hoisting stateful composables into stateless, reusable ones. Covers a ViewModel + StateFlow pattern for screen state, SharedFlow for one-time navigation events, and why collectAsStateWithLifecycle() beats collectAsState().
The 1.12.0-beta03 release fixes several iOS crashes (cancelling text input, a disposed accessibility element, an iOS 14 frame-rate crash), a desktop VerifyError build failure, and Web/WASM accessibility-sizing and scroll regressions, and updates Compose Hot Reload. The rest are nightly dev builds.
Third part of a series comparing live-gift animation formats, covering ByteDance's open-source PAG (Portable Animated Graphic). Explains its three mixable encoding modes (vector, bitmap sequence, video sequence) and shows PAGFile/PAGPlayer/PAGView integration on Android, iOS, and Web, plus a RecyclerView memory-leak gotcha.
"Oh my God, why did you scotch-tape a bunch of hammers together?" "It's ok! Nothing depends on this wall being destroyed efficiently."
Walks through building Android home screen widgets with Jetpack Glance, a Compose-style API that compiles to RemoteViews. Covers GlanceModifier's curated subset, the GlanceAppWidget/GlanceAppWidgetReceiver pair, data loading in provideGlance, and manifest registration.
Builds a functional Android home-screen launcher in Kotlin and Compose: the HOME/DEFAULT intent filter that qualifies an app as a launcher, a transparent windowShowWallpaper theme, Android 11+ package-visibility queries, and rendering the installed-app grid via PackageManager. Uses Kotlin 2.4.10, AGP 9.2.1 and a Gradle version catalog.
Shows how to group a custom Switch-style View (icon, title, subtitle, SwitchCompat) into one Talkback-focusable unit instead of separate stops. Covers disabling child importantForAccessibility, overriding onInitializeAccessibilityNodeInfo/Event to report as a Switch, and exposing state via setStateDescription.
Explains why Android needs JNI: it bridges Kotlin/Java running on ART to native C/C++ libraries like the Bluetooth stack, camera, and SQLite, and gives finer memory control for performance-critical code. Walks through Android Studio's Native C++ template, external fun, System.loadLibrary, and the generated JNIEXPORT function.
A roadmap for Android developers starting Android XR: distinguishes immersive (headsets, wired glasses) from augmented (audio/display glasses) experiences, and recommends Jetpack XR SDK plus Kotlin, Compose and existing Android skills as the fastest entry path over Unity, OpenXR or WebXR. Also flags Jetpack Compose Glimmer, a Compose toolkit built for glanceable display-glasses UI.
Goes beyond basic Room-plus-WorkManager advice to cover synchronization engine design: handling concurrent sync triggers with single-flight locking, offline-first writes, partial-failure retries, process death recovery, conflict resolution, soft deletes, pagination/delta sync, and idempotent uploads.
Walks through wiring Android App Links end to end: declaring intent filters, generating assetlinks.json with the Play App Signing SHA-256 fingerprint, hosting it correctly under Nginx without an SPA fallback swallowing it, and verifying deep links in a Kotlin Multiplatform app.
Traces how Android's ViewRootImpl registers a window with WindowManagerService through a Binder call, using a per-Activity token to authorize the window. Explains why invalid or dead tokens cause BadTokenException and "Activity has leaked window" crashes, tying window lifecycle to Activity lifecycle.
Explains that Google Play will require apps to target Android 16 (API level 36) for new submissions and updates starting August 31, 2026. Written in Turkish, it outlines what developers should check before raising targetSdkVersion.
Investigates Android 16's Expanded Dark Theme by comparing a light-only app's auto-generated dark mode against a hand-built Material 3 dark theme across fourteen UI patterns. Finds auto-dark preserves WCAG contrast ratios on plain text but underperforms by 1.8-2.5x on saturated colors and mid-tone grays, tracing the gap to HWUI's lightness-inversion formula in the renderer source.
Third part of a Room offline-first series tackling sync conflicts: adds a monotonic version field to entities and a ConflictResolver deciding whether a pull should overwrite local rows, never clobbering pending outbox edits. Includes unit tests and a server-wins policy with 409 handling.
A step-by-step Kotlin guide to Android's Room library: Entity/DAO/Database setup with KSP, Flow-based observation versus suspend calls, relations and indexes, and production habits like committed schema exports and safe migrations that avoid wiping user data on upgrade.
Describes diagnosing and fixing Google Play's 16 KB memory page size compatibility warning in a pure-Java legacy app, tracing incompatible native .so files to bundled third-party SDKs like Realm and updating build tooling and dependencies to resolve it.
Traces how a rendered Android frame actually reaches the screen: an app's Surface hands buffers to a BufferQueue, and the system process SurfaceFlinger consumes and composites every visible surface's latest buffer into one final image via Binder. Clarifies why status bars and wallpapers appear layered around app content the app never drew.
Announces Mobile DevTools, a new Google Play app billed as a pocket network debugger for Android developers. Post is written in Azerbaijani; the scraped page content is mostly Medium's own JS/routing boilerplate with no technical detail on the debugger itself.
Explains building a UPI (India's payment network) flow on Android in Kotlin: constructing the payment URI with Uri.Builder, launching the external UPI app via the modern Activity Result API instead of deprecated onActivityResult, and defensively parsing and validating the key-value response string for success, failure, or cancellation.
Details the :security module of a modular Android news app that signs every authenticated request with a hardware-backed secp256r1 EC key from AndroidKeyStore, attaching signature, timestamp, and public-key headers via an OkHttp AuthInterceptor. Also covers why AndroidKeyStore can't be unit-tested directly under Robolectric and how a SecurityManager interface seam works around it.
Developer overview of splitcash, a Kotlin Multiplatform expense-tracking app sharing UI via Compose Multiplatform, a Ktor/sqldelight backend, and shared DTOs, deep-link parsing, validation, and a sync-delta protocol between client and server modules.
JetBrains announces its Ship Kotlin Everywhere award at RevenueCat's Shipaton 2026 hackathon (Aug 1-Sep 30), offering a $30,000 prize pool for apps built with Kotlin Multiplatform and Compose Multiplatform across Android, iOS, desktop, and web, plus free IntelliJ IDEA Ultimate and Junie access.
A KMP architecture case study porting an 8,000-line 2013 Java game to Kotlin Multiplatform with Compose Multiplatform UI, showing how thin commonMain interfaces (graphics, hardware sensors) and a shared @Composable overlay stop platform-specific logic like steering sensitivity from drifting between Android and iOS.
Part 4 of a Kotlin Multiplatform series on building a reactive presentation layer with Flow and StateFlow. Discusses immutable UI state, StateFlow vs SharedFlow, search and pagination, offline-first refresh, and testing reactive ViewModels shared across Android and iOS.
Introduces Ferret, a Ktor plugin that captures HTTP and WebSocket traffic from a shared Kotlin Multiplatform networking layer into an on-device inspector for Android and iOS, replacing single-platform tools like Chucker or Flipper without proxies or certificates.
Argues Android architecture is moving UI state (text fields, dialog visibility, scroll position) out of ViewModel into remember/rememberSaveable, while navigation arguments move into Navigation 3's NavKey, leaving ViewModel as a business-logic state holder that produces UI state from repositories.
Argues module count is a poor proxy for real modularization, proposing to design Gradle module boundaries around change boundaries rather than folder layers. Covers dependency-direction rules, narrow feature-boundary contracts, convention plugins, and automated checks for keeping large Android codebases maintainable.
Broad career-style checklist of skills a senior Android engineer should have: Kotlin fluency, Compose/unidirectional UI architecture, lifecycle fundamentals, MVVM/MVI state management, offline-first networking, coroutines, testing strategy, and debugging/observability practices.
A list of interview questions for junior Android developers spanning Kotlin basics, Activity/Fragment lifecycles, MVVM architecture, Retrofit networking, Room storage, coroutines, and dependency injection, framed around what interviewers probe for beyond memorized definitions.
Explains how R8 in AGP 9.2 rewrites kotlinx.atomicfu's AtomicReferenceFieldUpdater calls to raw Unsafe field access, removing reflective overhead that dominated coroutine launch and cancel costs behind Modifier.clickable and LaunchedEffect—roughly doubling coroutine throughput without any code changes.
KSP 2.3.11 renames the coroutines core-jvm version catalog alias to coreJvm so it is no longer a prefix of another alias, removing the asProvider disambiguation workaround needed at every use site.
Shows how to pull a Git-hosted third-party Compose UI library into an Android project via JitPack, including adding the repository to settings.gradle.kts and declaring the dependency through the Gradle version catalog.
JetBrains' Qodana 2026.2 adds pull-request-level code coverage highlighting for changed lines, auto-detects Jacoco/Kover and other coverage report locations without extra config, and expands SAST with multi-file taint analysis, custom OpenGrep rules, and a new SABER benchmark runner for scoring findings against public vulnerability datasets.
Google announces global expansion of the Play Age Signals API, letting parents share a child's age range via Family Link so Android apps can tailor content and features per age group instead of applying one-size-fits-all rules. Rolls out to Australia and Canada by mid-August, globally later in 2026.
Google Play Console now lets developers permanently delete eligible apps instead of only unpublishing them, clearing dashboards of old prototypes and test builds. Deletion has a 7-day recovery window but drops update capability and historical stats for good.
Overview of Android supply-chain risk that distinguishes dev-only libraries (Mockito) from shipped ones (OkHttp, Glide), citing a pre-2.7.5 OkHttp TLS chain-pollution bug that allowed SSL-pinning bypass, plus unmaintained-dependency and license-compliance concerns for LGPL-style code.
Explains why Android emulators bog down machines: each instance is a full virtual device with its own system image, memory, and storage, and ARM-to-x86 instruction translation adds overhead. Gives a rule of thumb for choosing emulator vs. physical device vs. remote device farm when testing.
JetBrains-published tutorial explaining OAuth2 delegated authorization and JWT structure (header/payload/signature), then applying them to secure a Kotlin/Spring Boot REST API acting as a resource server that validates bearer tokens. A companion Ktor-based tutorial is planned.
No articles match your current filters.
Try broadening your selection or reset all filters.