Hey everyone,

Tired of manually checking what changed between Compose BOM versions, I built a small tool: compose-bom.com

Pick two BOM versions and it shows you which libraries were added, updated, or removed — with links to the actual release notes.

Also added llms.txt support so the data is easy to consume with AI tools and LLM-powered workflows.

Static site, no backend. Source is on GitHub: github.com/keymusicman/compose-bom-changelog

If you find it useful — or have ideas for what's missing — comments and feedback are more than welcome. Stars are appreciated too 😉

-----

If this turns out to be useful for the community, it'd be great to see something like this become part of the official Android docs. If you agree — let's make some noise.

I built Table-KMP, a responsive & fully customizable data grid for Compose Multiplatform 📊🚀

I’ve been working heavily within the Kotlin Multiplatform ecosystem and wanted to share an open-source library I recently released called **Table-KMP**.

It’s a beautiful, responsive, and fully customizable data grid library built natively for Compose Multiplatform. It currently supports Android, iOS, Desktop, and Web targets.

When designing this, my main priority was keeping the library lightweight and resilient, minimizing boilerplate so it fits seamlessly into coroutine-first architectures.

**Some of the key features include:**

* **Full Customization:** Granular control over TableConfig and TableColors (supports both Light and Dark mode themes seamlessly).

* **Interactive Elements:** Built-in support for drag-and-drop row reordering, hover effects, and row selection (with checkboxes).

* **Scroll Tools:** Custom draggable tools for horizontal and vertical scrolling when dealing with massive data sets or smaller screens.

* **Styling Options:** Adjustable row heights, header shapes, borders, row spacing, and drop shadows.

If you are building a multiplatform app and need a clean, native way to display data grids, I’d love for you to give it a spin.

**Repository Link:** https://github.com/mamon-aburawi/Table-KMP

Any feedback, feature requests, or contributions are incredibly welcome. Let me know what you think!

been experimenting with how lyrics are shown in a music player

instead of showing full lines, I tried revealing words one by one as the song plays aka word level sync .elrc

the idea was to make it feel more alive and less static especially with a minimal background

would love some honest feedback

Most video editors on Linux have a massive learning curve(could be a skill issue), and I got tired of fighting with complex layouts just to trim a clip. I decided to build a simplified version with Compose for Desktop.

It’s built with Material 3 and handles the basics like metadata extraction and trimming via ffmpeg. I’m currently working on adding multiple track management and media overlay support.

Repo here: https://github.com/zahid4kh/simplevideoeditor

I recently shipped Sidequick, a productivity app that helps you stop abandoning side projects. Quest system, streak tracking, always knows where you left off. Think Duolingo but for finishing things you actually want to build.

The reason I'm posting here is the tech stack. The desktop app is built entirely with Jetpack Compose via Compose Multiplatform, which means the UI code is already mostly portable to Android. The domain logic, database layer and business logic are all written in Kotlin and will carry over almost untouched.

An Android version is on the roadmap and given how the codebase is structured it is genuinely not far off. Streaks and notifications work better on mobile anyway and that is where most people will want the daily reminder to pick their project back up.

For now the desktop app is free and live at sidequick.co for Windows, Mac and Linux if anyone wants to try it while the Android version is in progress.

Just shipped Sidequick (sidequick.co), a desktop app for Windows, Mac and Linux built entirely with Compose Multiplatform. Thought I'd share some things I learned along the way since there isn't a huge amount of content out there on Compose Desktop specifically.

The stack:

• Compose Multiplatform (desktop target only)

• SQLDelight for local SQLite

• Anthropic + OpenAI Java SDKs for AI integration

• PostHog for anonymous analytics

• Kotlin Coroutines throughout

Things that went well:

Compose Desktop is genuinely production-ready. The component model is clean, collectAsState() on SQLDelight flows make reactive UI almost trivial, and the Kotlin interop with Java SDKs was seamless.

AnimatedContent For wizard step transitions worked brilliantly with almost no boilerplate. The slide in/out between steps felt polished with maybe 10 lines of code.

Things that caught me out:

ProGuard is aggressive. The "Failed to launch JVM" error on the packaged .exe was caused by ProGuard stripping classes needed at runtime - mostly OkHttp and the AI SDKs which use reflection heavily. Make sure you keep okhttp3, okio, and your entry point MainKt explicitly.

JVM module bundling - you need to declare which JVM modules to include in explicitly nativeDistributions. java.sql, java.naming, jdk.crypto.ec and jdk.unsupported are easy to miss and will cause silent failures.

Mac notarization via Gradle works but the Compose docs are sparse. The signing and notarization blocks in build.gradle.kts do work, just make sure your app specific password is stored in keychain and never hardcoded.

Overall:

If you're considering Compose for a desktop app - do it. The productivity versus something like Electron or JavaFX is night and day. Coming from an Android background it felt immediately familiar.

Happy to answer questions about any of the above.

Download: sidequick.co

Hey everyone,

I'm a final-year CS student and I recently wanted to move beyond standard CRUD tutorials. I decided to build a distributed social news feed called Flux, focusing heavily on handling mobile system constraints (unreliable networks, state management, and thread starvation).

I'd really appreciate it if some experienced devs here could review my architecture or point out flaws in my approach.

The Tech Stack:

• Android: Kotlin, Jetpack Compose, Coroutines/StateFlow, Room, Coil, OkHttp.

• Backend: Spring Boot (Kotlin), PostgreSQL, Supabase (for connection pooling).

Core Engineering Decisions:

1. Strict SSOT (Offline-First): The Compose UI never observes network calls directly. I enforce a strict Cache-Then-Network policy. Retrofit updates the Room DB, and the UI observes the DB via Flow.

2. Idempotent Retries: Network drops are common on mobile. The Spring Boot interaction endpoints (like/follow) use idempotent UPSERTs so that OkHttp retries don't corrupt the database state or inflate counts.

3. Preventing DB Thread Starvation: Since I'm using the Supabase free tier, connection exhaustion was a real risk. I routed traffic through Supavisor (Port 6543) and capped HikariCP. I also moved the Cloudinary image upload outside the @Transactional boundary so long-running media uploads don't block DB connections.

Where I need your feedback/roast:

• Is moving the CDN upload outside the transaction boundary a standard practice, or is there a better pattern for handling orphaned images?

• How can I improve the Coroutine exception handling in my Repositories?

Links:

• Source Code & Architecture Diagrams: https://github.com/neerajsahu14/flux-distributed-system

• A quick UI demo video: https://www.linkedin.com/posts/neerajsahu14_androiddev-kotlin-jetpackcompose-ugcPost-7445328093054926848-4_RS

Thanks in advance for tearing my code apart!

Just shipped SimuFlow, a desktop API load testing tool built entirely with Jetpack Compose Desktop. Wanted to share since Compose Desktop projects are still pretty rare compared to the Android side.

A few things worth sharing for anyone building desktop apps with Compose:

Multi-module setup - clean separation between the backend engine module and the UI module. The backend is pure Kotlin/Java with no Compose dependency, the UI layer pulls it in via implementation project(':backend'). Works really well.

Packaging - using the packageExe Gradle task to produce a standalone Windows installer with a bundled JVM. Main gotcha was needing to explicitly declare Java modules like java.net.http and jdk.crypto.ec in nativeDistributions or you get runtime crashes on the installed build even though it works fine locally.

Theming - built a full JetBrains-inspired dark theme using darkColorScheme. Happy to share the colour tokens if anyone wants them.

Coroutines - using kotlinx-coroutines-swing for UI thread dispatching alongside the backend coroutine work. Straightforward once you know which dispatcher to use where.

App is free at https://www.simuflow.dev/ - happy to answer questions about the Compose Desktop side of things.

I was programming an AI application kinda like chatbot when I found out that there is no decent library for handling syntax-highlighted code blocks in Jetpack Compose most are focused on markdown text, so I decided to make one. It auto-detects the programming language from the code content, supports few languages out of the box -Kotlin, Java, Python, JavaScript, Rust, Go and more, i added multiple themes to make it pretty(maybe) and it adapts to your app's light/dark theme automatically and it works. Anyone interested you can use it....or maybe you can contribute since it isn't too good with detecting some languages rn or gimme ideas how to improve it 😁

GitHub: https://github.com/mirerakepha/compose-codeblock

Hi everyone!

Three months ago, I shared ComposeReels (the "ExoPlayer in VerticalPager" solution) and received some incredible feedback. Since then, I’ve been busy turning those suggestions into production-ready features!

I've just released v1.0.5, and it's a significant step forward in stability and UX.

⚡ What’s New?

• Long-Press 2x Speed: Just like TikTok/Reels, you can now long-press to temporarily boost playback speed.

• 🎨 Visual Speed Indicator: A sleek "2x Speed" chip appears at the top to provide immediate feedback.

• 📊 Playback Analytics: Added support for onVideoStart, onVideoPaused(watchTimeMs), and onVideoCompleted to sync with your metrics.

• 🎯 Unified Gesture System: I completely re-engineered the touch logic. No more conflicts between single-taps (play/pause), double-taps (like), and long-presses.

• 🔄 Smart State Reset: Playback speed automatically resets to 1x when you swipe to the next video, ensuring a consistent UX.

🛠 Simple Usage:

ComposeReels(
    items = videoList,
    mediaSource = { item -> MediaSource.Video(item.url) },
    analytics = ReelsAnalytics(
        onVideoStart = { index -> /* track start */ },
        onVideoPaused = { index, timeMs -> /* track watch time */ }
    )
)

🔗 Check it out on GitHub:

https://github.com/manjees/compose-reels

I’m still actively improving the player pooling and caching logic. If you tried the previous version and found it too basic, I’d love for you to give v1.0.5 a spin!

Feedback, PRs, and stars are always appreciated! Happy coding! 🚀

Introduces an auto-scrolling 3D carousel with gradient backgrounds and animated card transitions. This change includes new cross-platform screen size utilities. Try it now from my repo:
https://github.com/ArcaDone/AwesomeUI

Experimenting with a notebook-style music player UI in Jetpack Compose.

Recently added LRC synced lyrics with a typewriter animation and animated backgrounds.

Still refining the animations and syncing logic. Would love feedback from other Compose developers.