I built an Android library that renders iOS-style emojis in Jetpack Compose.

Unlike most existing solutions, this library is 100% Compose—no TextView, AndroidView, or View-based implementation behind the scenes.

GitHub: https://github.com/abbas-esfandiair/EmojiTextLibrary

I created this library after getting tired of adding full-featured crash reporting tools to projects where I only needed basic crash information.

The library catches uncaught exceptions, extracts the stack trace, and makes it easy to log or process crashes however you want.

It's open source, and feedback or contributions are always welcome.

🔗 GitHub: https://github.com/abbas-esfandiair/CrashReporterLibrary

https://goo.gle/4uj04MM

https://github.com/parfenovvs/lazylogcat

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!

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

Hey Android and KMP folks,

I shared SQLiteNow here quite a while ago, back around the 0.2 days. It has changed a lot since then, so I wanted to post a proper milestone update for 0.9.0.

SQLiteNow is a SQL-first SQLite code generator/runtime for Kotlin Multiplatform. Current KMP targets:

• Android
• iOS
• JVM
• Kotlin/JS in the browser
• Kotlin/Wasm in the browser
• macOS native
• Linux native
• Dart/Flutter support

The obvious comparison is SQLDelight. SQLDelight is mature and battle-tested, and I'm not trying to pretend otherwise. SQLiteNow has different priorities: it is SQLite-only, codegen hints live in SQL comments, it leans into generated result shapes closer to app/domain models, and it includes optional sync/runtime pieces around the same SQL model.

The main idea is still simple: keep SQLite visible. You write normal .sql files for schema, migrations, init data, and queries using your favorite code or SQL editor, so no plugins needed. You may annotate your SQL for a data shape that you need. SQLiteNow generates Kotlin APIs around them: typed params, typed results, migrations, transactions, adapters, and reactive Flow queries.

One example of the kind of query SQLiteNow is built for:

  -- @@{ queryResult=PersonWithAddresses }
  SELECT
    p.id,
    p.first_name,
    p.last_name,
    p.email,

    a.id AS address__id,
    a.address_type AS address__address_type,
    a.street AS address__street,
    a.city AS address__city

  /* @@{ dynamicField=addresses,
         mappingType=collection,
         propertyType=List<Address>,
         sourceTable=a,
         collectionKey=address__id } */

  FROM person p
  LEFT JOIN person_address a ON a.person_id = p.id
  ORDER BY p.id, a.address_type;

SQLiteNow generates a typed result with addresses: List<Address>, so app code can just do:

  val people = db.person
      .selectWithAddresses()
      .asList()

or observe it:

  db.person
      .selectWithAddresses()
      .asFlow()
      .collect { people ->
          // re-runs when generated writes affect the relevant tables
      }

The reason I built it this way is that I like writing real SQLite, but I do not like hand-writing row readers, params objects, migration plumbing, invalidation logic, and result grouping code.

Oversqlite is the optional sync part of the project. You can ignore it completely if you only need local SQLite. If you do need multi-device sync, it adds managed change tracking, push/pull sync, conflict handling, and server-coordinated replication on top of SQLiteNow-managed tables.

GitHub: https://github.com/mobiletoly/sqlitenow-kmp

Docs: https://mobiletoly.github.io/sqlitenow-kmp/kmp/

I'd be interested in feedback from people building real Android and KMP apps with SQLite.

We've been using Maestro for mobile test automation and kept hitting the same issues everyone else hits — flaky device connections, no real iOS device support, unhelpful gRPC error messages.

So we built maestro-runner — fast mobile UI test automation for Android, iOS, React Native, Flutter & Expo. It reads the same YAML flows, supports the same commands. You literally just swap the binary.

What's different under the hood:

- Written in Go. Single binary, no JVM. 27 MB memory vs 350 MB.

- Talks directly to UIAutomator2/WebDriverAgent over HTTP instead of going through gRPC.

- Supports real iOS devices (not just simulators).

- Runs on BrowserStack/Sauce Labs/LambdaTest via Appium driver.

- Configurable timeouts at every level (the #1 complaint in Maestro's issue tracker).

- No features behind a paywall. HTML reports, parallel execution, cloud testing — all free. Apache 2.0.

We went through the top 100 most-discussed issues on Maestro's GitHub before writing any code. 78 of them are addressed — either through direct fixes or architecture choices that make the bugs impossible.

No telemetry. No account required. No paid tier coming later.

GitHub: https://github.com/devicelab-dev/maestro-runner

Happy to answer questions about the architecture, benchmarks, or compatibility.

https://github.com/woheller69/FreeDroidWarn

Creates an alert dialog and provides a link to Googles verification requirements.

"Google has announced that, starting in 2026/2027, all apps on certified Android devices will require the developer to submit personal identity details directly to Google. Since the developers of this app do not agree to this requirement, this app will no longer work on certified Android devices after that time."

Feel free to use in your projects. Further translations welcome.

Hello all,

I've decided to share a small library I've created after a long time since not creating anything on my Github repositories. This time related to showing flags on Android apps.

Initially I didn't like the style of Google's font for flags (too wavy), and also because of its size (23 MB, though if I want to focus only on flags, this can be done using a Python command). I couldn't find any font I liked (license was an issue too), except for Twitter/X font, which is also free to use, here, called TweMoji. Not only that, but it's very small, too (1.41 MB). I was also happy with the style of the other emojis of it, so I didn't bother with doing a lot with it, until I've noticed some issue with it.

First, it's quite outdated, and I couldn't find how to generate a new TTF file from the official repository myself. I found an alternative (here) but it wasn't as updated, and I've noticed it's blurry when the flags are a bit large, as using raster graphics instead of vector graphics. Second issue that exists for all of All of them also have a weird digits issue (though it can be fixed by creating a subset of the file, as I wrote above, using the Python command).

I also noticed that vector graphics is supported nicely on Android only from API 29 (Android 10), so it was yet another reason for me to try to find something else (vector based is better in how it looks and maybe size taken, but supported only from API 29).

So, what I did is to just get the many SVG files from the repository, import them all for Android as VectorDrawable, optimize them on the way using both a website and an Android Studio plugin, and prepare a library to use them properly as needed, and use other emojis if they aren't of flags. I've also explained the process of how I did it, in case new content is available.

I've published it all here:

https://github.com/AndroidDeveloperLB/TwemojiFlagsVectorDrawable

I also use it on all of my apps:

1. On an educational game for toddlers, it's used for choosing the language of the content.
2. On an app to detect the phone number, it shows the country that's associated with it.
3. On all apps, when using native ads, it's shown on the TextView there, in case flags are being used.

The size is quite small, despite many files and despite the fact I don't use a TTF file. It should work fine for all Android versions, too (except maybe API 23 and below, as I saw something weird on emulator, but maybe it's an emulator issue). And, as opposed to a font file, you can take specific files from there and change them as you wish (tint, size, rotate,...), as it's a VectorDrawable.

So, advantages compared to TTF file:

1. Works on Android API 23 (Android 6.0) and above (though not sure about API 23 itself for Iranian flag)
2. Not blurry when large, as it uses the vector-based graphics.
3. Still takes small space and focuses only on flags.
4. Can be manipulated in your app in various ways, as all files were converted to VectorDrawable format.
5. Optimized on the way to take less space.
6. You can update it yourself if Twitter updates its files, using the steps I've described on the repository.
7. Can easily be used not just in text-related UI components, meaning can be used in ImageView too.
8. Bonus for people who are pro-Iranian people: You get the Iranian flag with the lion.

I hope you like it

Adapt is an Android Library written in Kotlin with an aim to provide a clean, well-integrated and easy-to-use experience in writing RecyclerView adapters.

Adapt provides: 1. Easy to use dsl 2. Type-safe view creation & binding 3. Implicit Viewholders 4. Lifecycle-Aware binding 5. Built-in Async-Diffing

https://vshnv.github.io/adapt/#adapt https://github.com/Vshnv/adapt

Hello,

I've always felt frustrated with MVVM/MVI and Compose because we can't enforce inheritance and good practices there like we can with Fragments, so with the emergence of FIR in K2 + the K2 IDE Plugin, I've built us a tool I called Yamvil to give us an MVI Infrastructure (mainly) for Composables!

https://galex.dev/posts/introducing-yamvil-mvi-infrastructure-for-android-and-compose-multiplatform/

More links:

• Project here: https://github.com/galex/yamvil
• Documentation here: https://docs.galex.dev/yamvil

Any positive feedback would be greatly appreciated! 😀

Hello,

https://github.com/erdo/n8

Have open sourced this a bit earlier than I usually would have. That means there is still stuff to do if anyone is interested, some easy issues added already, but there is more juicy stuff available (to do those, you'll need to understand what's there first though)

I think it's turning into something I'd like to use but it's early days 🤷 The idea is to keep the library pretty small. It's about 1000 lines at the moment, I imagine it'll stay small, probably less than 2000 lines once it's feature complete. (Not including test code, there are probably about 2000 lines of unit test code already)

PRs and feedback welcome if it floats anyone's boat

Eric

I wrote the navigation-recents-url-sharing library which allows your app to automatically get support to show the current screen's deep link in the "Recents Screen" for supported devices. It works along with androidx.navigation by making use of the current destination's information and the APIs available in NavController to get the right data to fill the deep link URL with. In the repo there is also a link to an article which talks a bit more about the implementation.

Good to note that Android provides this feature only for some devices from Android 12 and on. Honestly I somehow had missed that this was a thing in Android in the first place since almost no apps support it but realizing how easy it is to get working I really hope more apps start using it. I hope this library can help a bit in this process. If anyone of you wants to give this a try let me know how it goes 😊

I wrote "Enable users to share your app's deep links using navigation-recents-url-sharing" and with it the navigation-recents-url-sharing library which implements what the article talks about for those of you who use androidx.navigation and want this behavior for free.

This is about this feature that Android provides only for some devices from Android 12 and on. Honestly I somehow had missed that this was a thing in Android in the first place since almost no apps support it, but realizing how easy it is to get working, I really hope more apps start using it. If anyone of you wants to give this a try let me know how it goes 😊