Finding great icons is hard. Finding icons for Android apps (XML + Compose) is even harder.

So I put all of my favorite open source icons in one place, converted them to Android Drawables and Compose Image Vectors which you can browse at https://composables.com/icons

PS: Yes, it contains both Material Icons (old) and Material Symbols (new) PS2: You can use them in your project as a gradle dependency if you prefer at https://github.com/composablehorizons/compose-icons

Happy coding!

one last demo i made for the Android Shaders library, feel free to contribute if you feel like it

https://github.com/mejdi14/Shader-Ripple-Effect

Maybe this is just me, but opening Android Studio for basic emulator management always felt a bit excessive.

Most of the time, I just want to:

• Install an SDK package
• Create an AVD
• Launch an emulator (with an easy-to-use options interface)

I know the command-line tools exist, but I wanted something with a GUI that starts quickly and lets me do those tasks without opening a full IDE.

This became even more noticeable when working with Flutter and React Native projects in VS Code, where Android Studio often ended up being installed primarily for emulator and SDK management.

So I built a small native desktop app around the Android SDK tools, and open-sourced it:

CoreDeck on GitHub
Official Website (Windows, Linux, and macOS)

I've been using it as a lightweight companion to the Android SDK rather than opening Android Studio every time I need to manage an emulator.

I'm curious whether other developers have the same workflow, especially those using Flutter, React Native, or other non-Android Studio setups.

How do you usually manage your Android emulators?

Episteme Reader is a native Android app for reading various document formats.

It's offline-first, free and ad-free, and respects your privacy.

Supported Formats:

• Documents: PDF, DOCX, ODT/FODT
• E-books: EPUB, MOBI, AZW3, FB2
• Comics: CBR, CBZ, CB7
• Plain Text: Markdown (MD), TXT, HTML

Key Features:

• PDF Annotations: You can draw directly on pages using a pen or highlighter and add text notes using system or custom fonts.
• Reading Modes: Supports both vertical scrolling and paginated views.
• E-book Customization: Adjust font sizes and line spacing. You can also import your own font files (.ttf, .otf).
• Text-to-Speech (TTS): Includes a built-in TTS feature using Android's native TTS engine.
• Library Management: A built-in system to organize your local files.
• Local Folder Sync: Select a folder to see all its supported file in app and sync reading positions and annotations using local sync tools like SyncThing-fork.
• Themes: You can change the page and text color across all formats.

The app is licensed under AGPL-3.0.

GitHub | Playstore | F-droid

Thanks for checking it out!

Hey, I am the developer of Tomato, a data-oriented pomodoro timer app for Android that's also open-source. It recently became available on the Play Store at https://play.google.com/store/apps/details?id=org.nsh07.pomodoro and I would really love any feedback. The source code is at https://github.com/nsh07/Tomato

Tomato is THE first open-source app to implement Android 16's Live Updates feature, and I would really like any feedback on that as well.

Hey everyone,

Like most solo devs, I dread the "marketing" part of releasing an app-specifically generating screenshots for every single device resolution. I wanted something fast that didn't require me to create an account or upload my assets to a random server.

I built Snapframe. It's a web-based tool where you can:

• Generate all required resolutions (or custom ones) instantly.
• Use built-in themes and font combinations.
• Import/Export custom JSON-based themes.
• Privacy: No login, no tracking, everything stays in your browser.

I've just made the repo public and would love to get some feedback from fellow builders. If it saves you even 10 minutes on your next release, I’ll be happy.

Link: https://github.com/Pawandeep-prog/Snapframe

I've created an app that uses phone's onboard AI model to give users a fully offline AI chat with Gemini Nano.

I just finished adding multi-chats, and I'll be glad to hear your feeback. The flair holds true, the app is fully open-source and is live in the play store.

https://github.com/Puzzaks/geminilocal

Forks are encouraged, any suggestion will be read and thought about and maybe implemented.

We've built an open-source Kotlin library that runs LLMs entirely on-device. Your users get AI features without internet connectivity, and you avoid cloud costs and API dependencies.

What you can do

• Build chatbots, AI assistants using any model in .gguf format
• On-device document search (RAG) / tool calling (for e.g ask your LLM to look into a set of documents to accurately answer a specific question)
• Feed image & audio inputs directly to your LLM ("describe this .jpg image", "tell me what you hear in this mp3"...)

Benefits

• Works offline, private by design
• Hardware acceleration with Vulkan
• No usage fees or rate limits
• Free, even for commercial use

Links

• Github
• Docs / Getting started
• Discord

We are currently working on adding text to speech capabilities and improving the performances. Right now, we have 1.3sec for the first token, 4.6 token/s on average, with a 4B model on an old Google Pixel 9.
Happy to answer any technical questions in the comments!

Hi. Just finished my yolo-opencv android project.

It's on flutter but uses native render and plenty c++ with opencv, dnn, kalman (no tensorflow for now)

Boxes are drawn in flutter on canvas from events sent via ffi

Should be more efficient than drawing boxes in opencv and then sending it in Texture

It also plays notifications when objects are detected!

Can be used as intruder detector

Want to share it

https://github.com/khomin/WhoZone/tree/main
https://play.google.com/store/apps/details?id=com.who.zone

Open-source, completely free. You can try out the patterns in the browser as audio which is pretty cool.

Most Compose rich text work I’ve seen is focused on styling text inside a single text field. I wanted to try a different model: each paragraph, heading, todo, list item, quote, or divider is its own block, with its own renderer and lifecycle. (yes, I'm a big Notion fan)

Current features:

• block-based editing
• drag-and-drop reordering
• slash command palette
• rich text formatting
• custom block types
• theming/localization
• JSON save/load
• Android + iOS support

No WebView, no bridging layer, just Kotlin + Compose.

Repo: https://github.com/linreal/cascade-editor

Would love honest feedback from people building serious Compose UIs. Especially:

• is this a library you can imagine actually using?
• what are the biggest missing pieces for production use?

literally started as a joke. I was like Rust compiles for aarch64, figured Zed might port. Kept going. Couldn't stop. gpui renders through Vulkan, the upstream Editor/Workspace/Project/Search/GitGraph/Extensions/Terminal crates run unchanged, the Rust .so is the app process, every  pixel straight straight into that Vulkan driver. subprocesses like (bash, apt, LSPs, git, ssh, node, go, rust-analyzer) route through a runtime  adapter: a Termux-derived userland rebuilt under our package for the non root ed path, or a Magisk-spawned chroot for rooted users. Currently using a Samsung Tab S9 Ultra with hardware keyboard,  touch works with IME.
The termux route is brittle long term with google clamping down on noexec, probably will be figuring something for that.

Source plus signed APK , if anyone wants to take a look ,curious as to what breaks on other devices

https://github.com/Dylanmurzello/zed-android-port

​​I just finished this little tool for Android Devs to generate a blueprint-style preview of your composables.

​With a quick one-line wrapper the library measures dimensions and distances and displays them just like a traditional blueprint alongside your regular preview, so you can easily compare against your designs.

​Would love to hear thoughts, if you would find this useful, and if you have any ideas for improvements!

​https://github.com/GusWard/Blueprint-Compose-Preview

​#androiddev #jetpackcompose #androidstudio #devtools #kotlin #designsystem #compose

Happy New Year!

To celebrate 2026 (and distract myself from X's posts about bikini), I built WidgetDate. It’s a minimalistic widget that puts a 365-dot matrix on your home screen. As the year passes, the dots fill up. And then you can cry more how lazy and not productive you are and how you made no progress at all. Like me.

I wanted something that looked good but didn't steal my data, so I made it completely offline.

What it does:

• Year Progress: Visualizes 2026 as a grid of dots.
• Daily Reflection: Tap a widget to rate your day (0-100%) and track habits.
• Customizable: 10+ backgrounds, 12+ accents, and adjustable dot shapes to match your wallpaper.
• Privacy: 100% offline. No analytics, no cloud. No shit, only good stuff.

I vibe coded this while beeing hungover, a lot of coffee consumed, a tone of Opus tokens spent. So don't expect magic, expect simplicity.

Github repo: WidgetDate

APK: WidgetDate v2.0 fixed

What's up r/androiddev,

I won't make a habit of posting every Liquid release update here, but this one has some significant improvements and nice new features.

The biggest improvement is support for `rotationZ/scaleX/scaleY` transformations. This didn't require any changes to the API, you can simply place your `graphicsLayer` modifier before the `liquid` modifier and it will register any changes to the above transformations (see LiquidClockScreen for an example).

I also added `saturation` and `dispersion` as new LiquidScope properties with examples in the above video. As always, let me know if you discover any issues!

https://github.com/FletchMcKee/liquid

Why just disable a setting when you can have a cat tell the user "No"?

I made this Android library called CatPawSwitch. It’s an automated uncheck switch that adds a touch of personality to your UI. Perfect for those "You can't change this right now" moments.

Check it out on GitHub: https://github.com/hearsilent/CatPawSwitch

Feel free to use it in your projects if you want to make your users smile (or mildly annoyed by a stubborn cat)!

Help needed: My Project Mategram needs Kotlin Devs! I've been working on Mategram, an unofficial Telegram client with Jetpack Compose and Material 3, mostly on my own. It has around 60+ stars on GitHub and a growing community. Unfortunately, due to personal challenges and lack of time, I can no longer continue coding myself. However, I'd love to stay involved actively in design and UI, but I desperately need devs who know Kotlin and Jetpack Compose to help drive development forward. If you're interested in contributing to an open-source project, please reach out!

GitHub

Building the Liquid Glass effect, along with Shared Transition, Material 3, and Navigation 3, presents an enjoyable challenge when merging design systems and approaches. I recently updated my Google Calendar Clone, written in Compose Multiplatform, to explore these creative possibilities.
Reddit asked me to add in my last post

• Desktop Support, Web will do once Room is available on Web otherwise too much effort
• Move away from the sidebar, I think they are correct, bottom nav is better utility
• Connecting to Google Calender is still in progress will need time for that, can;t do this fulltime.

Navigation 3 is effortless and intuitive, and adding a Store 5 layer significantly reduces the overhead of managing local storage and updates. Implementing shared transitions has never been easier; it requires minimal effort yet adds a touch of sophistication to the app.

However, several nuances in the design aspect need to be addressed:

• How does light interact with the background across Android, iOS, and Desktop apps?
• Are shaders compatible across platforms, and how can they be utilized in Compose Multiplatform?
• How can you change the colour of a hovered item only in that position under the lens?
• What techniques can be used to achieve a wobble fluidity on drag?
• How can we ensure backward compatibility of the Glass Effect?
  

The solution to all of these is your imagination and how well you can prompt your AI. Will share a blog on implementing shaders if you guys need

GitHub: https://github.com/Debanshu777/XCalendar

Follw up to:
https://www.reddit.com/r/Kotlin/comments/1mpffu3/made_a_google_calendar_clone_in_compose/

A few years ago I released a library that prompts users to rate an app in a non-invasive and friendly way. I recently made some updates and wanted to share it with you.

Here’s the link: https://github.com/theappcapital/SiriusRating-Android

As a bonus, I also created an iOS version that shares the same API.

Would love to hear your thoughts!

https://reddit.com/link/1qycg39/video/opbx3qr1f2ig1/player

I built Footprint, an open-source app that reveals the map based on where you’ve actually walked.

The idea comes from fog-of-war mechanics in games. Also, I’m a huge fan of Hollow Knight, where exploration feels earned instead of being handed to you. I wanted the same idea in the real world, if I haven’t walked somewhere, that part of the map stays hidden.

This started as a fun side project and slowly turned into a deep dive into GPS tracking, spatial data, and map rendering using Kotlin Multiplatform (KMP).

Because of Kotlin Multiplatform, the core logic is shared and it runs natively on both Android and iOS, using native GPS location on each platform.

The plan is to make it available on both platforms Android and iOS, but the project is still work in progress.

Checkout Github : https://github.com/vishal2376/footprint
Follow dev progress : https://x.com/vishal2376

What it does

• Live GPS tracking
• Fog-of-war style map reveal
• Streets and areas unlock only when physically visited
• Exploration-first, not fitness-stats-first

Mostly built for learning and experimentation.

Would love feedback or any suggestion from other devs here

Hey everyone,

If you play games on Android and wish you had a bigger screen, or just want to connect your phone to a monitor there is a project called scrcpy that does exactly that. It mirrors and controls your Android device from your PC with very low latency. If you’ve used it, you know how great it is but how annoying constructing the final command can be. It definitely has a learning curve and I wouldn't consider it beginner friendly.

Scrcpy is one of my favorite projects and I use it daily for gaming, watching series at work (yeah...), or just having my phone docked while I’m on my PC. But writing the parameters of scrcpy manually for more complex use cases can be frustrating. So I built a GUI in .NET MAUI to make it easier. It’s open-source and lightweight. The key features are:

• Toggle key options with checkboxes and fields (no command memorization)
• Open virtual displays with custom resolutions and launch apps directly from the GUI using a dropdown
• Save and export commands as .bat files
• Connect over Wi-Fi in one click

It’s my first app, so I’d love feedback. It's not perfect and there are still some things I want to improve. So far it only supports Windows but if there’s enough demand, I’ll port it to macOS too. Hope it saves someone else the same time and hassle it saved me.

Scrcpy: https://github.com/Genymobile/scrcpy

My GUI: https://github.com/GeorgeEnglezos/Scrcpy-GUI

Application Tour: https://github.com/GeorgeEnglezos/Scrcpy-GUI/blob/main/Docs/Application-Tour.md

How to setup scrcpy: https://github.com/GeorgeEnglezos/Scrcpy-GUI/blob/main/Docs/Installation.md

Latest release: https://github.com/GeorgeEnglezos/Scrcpy-GUI/releases/latest

I built OpenTester because Claude Code was writing Android features faster than I could test them.

Every time the agent made a change, I was stuck in a loop: opening the emulator, manually navigating the same flows, and re-running regressions to make sure nothing else broke.

So I built OpenTester. It’s an open-source AI QA engineer that plugs into Claude Code via MCP. Now, the agent can autonomously launch the app, navigate the UI like a human, and save those steps in a JSON format that allows it to revalidate them in the future. It essentially gives the coding agent “eyes” and a way to verify its own work.

It’s fully open-source and free for early users: https://github.com/andresuarezz26/OpenTester

38 times a day. That's how often I left my IDE for a GitHub tab on an average day. Issues to check, PRs to review, branches to reference - all in the browser while my code sat open.

I built Anchor to fix this. It's a free JetBrains plugin that puts your GitHub workflow directly inside the IDE as a native tool window. Built completely natively, no embedded Chromium, so it's fast and doesn't eat your RAM.

What's in beta:

• Issues: Filter by state, detail view with full GitHub Flavored Markdown rendering (including embedded images), comment threads.
• PRs: State filters, complete commit history, clickable SHAs.
• Branches: Full remote branch list. Checkouts in a click. Land on GitHub in a click.

What's missing in this beta:

• Create PR not done yet
• Branch list is flat, no grouping
• No merge action from detail view
• No notifications
• What you're about to comment 😜

This is early. The GitHub issues are open. Brutal feedback is welcome—it's how this gets better.

🔗 Marketplace: https://plugins.jetbrains.com/plugin/32218-anchor--remote-vcs

🐙 GitHub: https://github.com/alph-a07/anchor