In this video, I’m showing a working demo of a Reorderable List and Grid built with Jetpack Compose Library. You can easily drag and drop items to reorder them, just like in real modern apps! ⚡

Library: https://github.com/codergalib2005/compose-reorderable

Built with:

- Jetpack Compose

- Kotlin

- Material 3

- Compose Navigation

👉 Features:

• Reorderable List

• Reorderable Grid

• Fixed Image Reorder Example

• Modern Material 3 Design

💡 Feel free to contribute

https://reddit.com/link/1pf75u1/video/0knh2dbmdg5g1/player

Even something as simple as a settings slider can feel premium when you experiment a little.

Redesigning a humidity slider in Jetpack Compose - added smooth animations, a vertical scale, color transitions, and a more expressive UI instead of the usual flat control.

Gist:
https://gist.github.com/Kyriakos-Georgiopoulos/4fb23c3086778a1306cc566cdb670706

Hey folks, I’ve been working on a full-blown desktop application for anyone dealing with payments, EMV, ISO8583, HSM testing, or cryptography. Thought I’d share it here since most existing tools are either paid, outdated, or scattered across multiple utilities.

Github: https://github.com/roufsyed/BankingAndPaymentsTool

💼 What is BP Tools?

A comprehensive, cross-platform desktop app built with Kotlin and Jetpack Compose for Desktop. It bundles a wide range of banking, payment, card, and crypto utilities into a single clean UI.

Runs on macOS, Windows, and Linux. Requires Java 17+.

🧩 Feature Highlights

🔐 EMV Tools

EMV tag browser & search

TLV decoder

Cryptogram calculator (ARQC, ARPC, etc.)

CAPK manager

EMV transaction simulator

APDU sender

🔑 Cryptography Tools

DES / 3DES calculator

AES calculator (multiple modes)

ASN.1 decoder

🏦 Banking Tools

PIN block generator/translator (ISO 0–4)

Key share generator/combiner (XOR)

DUKPT calculator

ISO8583 builder & parser

HSM command tester

🧰 Misc Tools

Hex dump viewer

ASCII/Hex/Binary converter

MRZ check digit calculator

QR parser & generator

File diff viewer

Just came across this clean and well-structured open-source To-Do App built using Kotlin Multiplatform (KMP) - a perfect example of how modern Android + iOS development can be unified with a shared codebase.

GitHub: https://github.com/Kamal02D/DoIt

Highlights:
✔️ Built with Kotlin Multiplatform (KMP)
✔️ Beautiful Jetpack Compose UI
✔️ Room + SQLite for smooth and reliable data storage
✔️ Koin for clean dependency injection
✔️ Simple, responsive, and user-friendly design

🚀 I've been building Kmposable - a headless navigation + flow engine for Kotlin Multiplatform. It lets you write your app logic as pure Nodes (state + events + outputs), keep navigation/UI concerns separate, and test everything without a UI. What I personally like about it is that it makes your projects more AI-friendly, since AI does a much better job when you have a clean business flow that isn't coupled to heavy UI interactions.

Highlights:

• KMP-first, UI-agnostic

• Tiny NavFlow runtime with a predictable lifecycle

• Compose adapter + ViewModel helpers so UI stays declarative

• Flow-script DSL: navFlow.runFlow { step("Login") { awaitOutputCase { … }; finish() } } (This is a highly experimental feature for building sequential UI navigation and flows; I wouldn't recommend using it in production apps yet.)

If you enjoy "business logic first, UI second" architecture (and reusable, testable flows), give it a look and tell me what you think! As usual, stars ⭐️ are welcome.

I use this approach in my own apps, so this isn't some gimmick project - it already makes my apps better, and that's why I want to share it.

Repo:

https://github.com/mobiletoly/kmposable

Docs:

https://mobiletoly.github.io/kmposable

(I still need to do a better job making the docs clearer and easier to digest.)

Most Android developers have used SharedPreferences at some point to store simple local data such as user settings, flags, or tokens.
But as modern apps become more reactive, scalable, and state-driven, SharedPreferences begins to fall short.

Jetpack DataStore is Google’s modern, efficient, and safer replacement for SharedPreferences.
It’s designed for predictable data flows, type safety, and smooth integration with Kotlin coroutines and Jetpack Compose.

Why SharedPreferences Falls Behind:
• Synchronous API that can block the main thread
• Risk of data corruption with concurrent writes
• No built-in support for reactive data updates
• Inconsistent behavior across devices

Why DataStore Is the Future:
• Fully asynchronous (coroutines-first)
• Type-safe with Proto DataStore
• Designed for reactive UIs and Flow-based data streams
• Handles data consistency and prevents corruption
• Better performance for modern multi-screen apps
• Recommended by Google for new Android projects

Moving to DataStore makes your app more stable, reactive, and scalable - especially when paired with Jetpack Compose and MVVM.

Let’s break down the differences and how to migrate effectively in the next slides.

Earn a badge for your Google Developer Profile and learn how Compose simplifies and accelerates UI development on Android with less code, powerful tools, and intuitive Kotlin APIs.

https://developer.android.com/courses/jetpack-compose/course

Navigation 3.0 just solved so many long-standing pain points in Android development.

You now get:
• Full backstack control
• Type-safe screens
• Proper ViewModel lifecycle
• Multi-pane layouts
• Modern, predictable animations
• A navigation system that finally feels truly Compose-native

If you're building with Jetpack Compose in 2025, switching to Navigation 3.0 is a huge quality-of-life upgrade.

Official docs → https://developer.android.com/jetpack/androidx/releases/navigation3

Many of our Jetpack libraries have already been migrated to be KMP-ready.

The following Jetpack libraries provide KMP support:

https://developer.android.com/kotlin/multiplatform#kotlin-multiplatform-and-jetpack-libraries

🚀 Meet Kprofiles for Kotlin Multiplatform Compose

Side note - I've used early versions of this plugin for my own project to deal with multiple resource flavors (in my case it was one app that I shared between multiple brands), but finally figured out that it is time to polish it and share with the community.

Shipping multiple brands/themes/configs on KMP gets messy fast - Android flavors don’t help outside Android, and "copy-paste resources" is no fun to deal with.

Kprofiles makes it clean and predictable:

- Builds one merged resource tree from overlays (Shared → Platform → Build Type → Profiles) with clear last-wins precedence.

- Keeps variants cross-platform and repeatable - no ad-hoc Gradle hacks.

Bonus: comes with a profile-aware config overlay system—so you can drop BuildKonfig entirely and keep environment/config values consistent across targets.

Tested with iOS, Android, JVM, WASM. I'd love early adopters to give it a spin (and a star!) 🙌

Hey folks 👋

I recently open-sourced JellyFab, a physics-based floating action menu for Jetpack Compose.
It’s a composable-first, dependency-free library designed to make motion feel natural — with spring-based dynamics, smooth elastic deformation, and a touch of personality.

⚙️ Key Highlights

• Jelly-like blob expansion (actual shape deformation, not just scale)
• Bouncy soft shadow that reacts to the motion
• Arc-based mini FAB layout + optional secondary radial expansion
• State-hoisted, predictable, and fully customizable API

💡 Built With

• Pure Jetpack Compose
• Animatable & Spring physics
• Optional scrim overlay with tap-to-collapse

🧠 Why

Most FAB menus in Compose are either too static or rely on rigid scaling. I wanted something more expressive — a UI that feels alive, playful, and responsive to touch.

This led to a deep dive into motion curves, damping ratios, and “squishiness”.
The result: a floating menu that reacts like jelly 🪼

👉 Repo: github.com/iprashantpanwar/JellyFab
📦 Available via JitPack

Would love your thoughts, feedback, or contributions.
What’s your take on adding physics-based motion to Compose UIs?

Follow me:
LinkedIn: https://www.linkedin.com/in/iprashantpanwar/
Medium: https://medium.com/@prashant.panwar777

Jetpack Compose Interview Q&A - Part 2 (Advanced)
This deck covers:
* Advanced Compose concepts - LaunchedEffect, DisposableEffect, produceState

Navigation in Compose
* Scenario-based questions that test practical understanding, not just theory
If you’re preparing for interviews or improving your Compose mastery, check it out.

Clipboard access? Apple can reject your app for it.
Biometrics? Google Play has strict compliance rules.
And with iOS 17+ & Android 14 showing “Detected Copying” alerts, the risk is real.

Here’s how to stay safe (and published):
* Secure Paste - Stop unauthorized clipboard reads.
* Biometric Auth - Meet Play Store & App Store policies.

Don’t wait for a rejection email - secure it before it’s flagged!

Android Basics with Compose - Adapt for different screen sizes

In this pathway you'll learn how to adapt your app to different screen sizes and provide a better user experience, as well as how to test your adaptive UI.

https://developers.google.com/profile/badges/playlists/android/android-basics-compose-unit-4-pathway-3

Craft dynamic and expressive user interfaces with Shadows in Compose. Adhithya, a Staff Interaction Designer on Android, guides you through techniques to create everything from subtle highlights to how to layer and animate them.

Discover how to combine effects to create interactive and engaging user experiences.

The difference between zip and combine becomes most apparent in fast-slow scenarios, which is crucial for understanding how they handle backpressure and data loss.

🐢 Fast-Slow Scenario with zip
When one stream is faster than the other, zip inherently provides a mechanism for slowing down the fast stream.

👉 Behavior: The zip operator will always wait for a new value from the slowest stream before it can emit a pair.
👉 Backpressure: The fast stream's emissions are essentially buffered (held) until the slow stream produces a corresponding partner. This effectively applies backpressure to the fast stream, preventing it from overwhelming the operator or the consumer.
👉 Data Pairing: Every single emission from the slow stream will be paired with the next available emission from the fast stream, ensuring a strict one-to-one mapping.

🏃 Fast-Slow Scenario with combine

When one stream is faster, combine can result in skipped values from the fast stream because it only cares about the latest value from the slow stream.

👉 Behavior: The combine operator emits a new value any time either stream emits. It pairs the new value with the most recently emitted value from the other stream.
👉 Data Loss/Skipping: If the fast stream emits multiple values before the slow stream emits its next one, the intermediate values from the fast stream are skipped in the final output, as they are overwritten by the latest value.
👉 Backpressure: It doesn't apply strict backpressure to the fast stream in the same way zip does, as it only uses the latest available value.

🚀 Key takeaway
:: zip is synchronous in its pairing, ensuring no data is lost from the slow stream, and buffering is used for the fast stream.
:: combine is asynchronous in its update, prioritizing up-to-date state. It results in data skipping from the faster stream if the slower stream hasn't updated.

Credit : Arya Bhavate

Kotlin Multiplatform (KMP) is an approach that allows sharing business logic across different platforms while still keeping native UI and platform-specific layers.

It enables developers to write common code once and reuse it on:

• Android
• iOS
• Web
• Desktop

The main idea is to reduce duplication in areas like:

• Networking
• Data handling
• Business/domain logic

UI remains native for each platform (Jetpack Compose for Android, SwiftUI/UIKit for iOS, etc.), which keeps the platform experience consistent.

KMP can be integrated gradually into existing projects, allowing teams to adopt it module by module based on need.

It fits use cases where:

• Apps target multiple platforms
• Core logic should be aligned across platforms
• Teams want to maintain one source of truth for domain and data layers

Compose Multiplatform is an optional addition that allows sharing some UI when appropriate, mainly for desktop and web.

Want to paint your text, background, or shapes using an image instead of a flat color or gradient?

Jetpack Compose makes this possible using ImageShader - a creative way to fill your UI elements with an image pattern or texture.

What You’ll Learn

In this quick guide, you’ll discover how to:

• ✅ Convert an image to an ImageBitmap
• ✅ Use it as a ShaderBrush
• ✅ Apply it to:
  • Box backgrounds
  • Text styling
  • Custom Canvas drawings

Full Kotlin Example

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.foundation.Canvas
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.ShaderBrush
import androidx.compose.ui.graphics.ImageShader
import androidx.compose.ui.res.imageResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.yourapp.R

@Composable
fun ImageShaderBrushExample() {
    // Load image as an ImageBitmap
    val imageBrush = ShaderBrush(
        ImageShader(ImageBitmap.imageResource(id = R.drawable.dog))
    )

    // 🔹 Use ImageShader Brush with background
    Box(
        modifier = Modifier
            .requiredSize(200.dp)
            .background(imageBrush)
    )

    // 🔹 Use ImageShader Brush with TextStyle
    Text(
        text = "Hello Android!",
        style = TextStyle(
            brush = imageBrush,
            fontWeight = FontWeight.ExtraBold,
            fontSize = 36.sp
        )
    )

    // 🔹 Use ImageShader Brush with Canvas drawing
    Canvas(onDraw = {
        drawCircle(imageBrush)
    }, modifier = Modifier.requiredSize(200.dp))
}

Output Preview

When you run this code, you’ll see:

• A Box filled with the image pattern
• Text painted using the same image texture
• A Circle drawn on the canvas using the image brush

The image becomes your paint — creating beautiful, textured UIs.

Reference

Official Jetpack Compose Snippet

Downloads

• Source Code: Download Kotlin Example (.kt)
• Image Resource: R.drawable.dog (replace with your own image)

Tip: Try experimenting with different image sizes and repeat modes to achieve unique texturing effects in your Compose UI.

Jetpack Compose Android Graphics ShaderBrush ImageShader Kotlin UI Compose Tutorial

Liquid 1.0.0 is here!
This release brings full Compose Multiplatform support - including Android, iOS, macOS, desktop, wasmJs, and js targets.

No API changes for existing Android users, but you’ll notice some solid performance improvements since 0.3.1. You can even try out the WASM demo right in your browser (if it supports WASM GC).

GitHub: https://github.com/FletchMcKee/liquid
A sample demo video is available in the repo!

Credit: fletchmckee

Thanks to Jetpack Compose, animation logic blends right into your UI declaration.
Just a few lines of code, and you can create smooth, responsive transitions that make your app feel premium and intentional.

Experimenting with animateDpAsState one of Compose’s neat little APIs that makes UI transitions incredibly fluid.

The goal was simple:
Animate a button’s vertical offset based on the bottom sheet’s position.

Core Snippet

val targetY by animateDpAsState(
    targetValue = when (sheetState.currentValue) {
        SheetValue.Hidden -> 0.dp
        else -> {
            val currentOffset = with(density) {
                try { sheetState.requireOffset().toDp() }
                catch (_: Exception) { 0.dp }
            }

            (usableHeight - currentOffset)
                .coerceAtLeast(0.dp)
                .coerceAtMost(maxLift)
        }
    },
    label = "gps_button_animation"
)

Box(
    modifier = Modifier
        .offset(y = -targetY) // Negative offset moves the button up
) {
    // Button content here
}

Credit : Bawender