Need a bit more work… Android 11, btw. Still fully on the hardware path. #AndroidDev

Imla update, back after a long break and feeling inspired again. Reworked the renderer and layer composition, made effect layers aware of each other, reduced temporal flicker, and switched to a real progressive blur instead of alpha masking. Lots more planned 😊 #AndroidDev

One more blur pass… right? #AndroidDev #JetpackCompose

So glad this is finally out! androidx.webgpu brings the WebGPU API to Android developers. Having access to a modern GPU API in Kotlin without dealing with the OpenGL legacy nor the complexity of Vulkan is exciting! developer.android.com/jetpack/andr...

New blog post on how to render beautiful soft shadows projected by the user's finger with Jetpack Compose. www.romainguy.dev/posts/2025/f...

With us in spirit: St. Chet! @droidcon.bsky.social #dcldn25 @chethaase.com

Nice progress, but "seamless" isn’t even on the horizon yet.

PSA for #AndroidDev: Google's #16KB page size requirement starts Nov 1st - literally next week. Just discovered a really nasty corner case that ate hours of my time today. If ur using native libs this might save u from last-minute Play Store rejections. Here's what I found 🧵

Working on more custom options - Compose Stability Analyzer

I wrote a deep dive into Jetpack Compose class stability inference in the Jetpack Compose Internals book. People loved it, got great feedback. Now, @github_skydoves decided to write a masterpiece to expand on this topic. Absolute cinema, give it a read and a star! ⭐️ github.com/skydoves/com...

Published a new article, 'Understanding retain{} internals: A Scope-based State Preservation in Jetpack Compose'. Now you can try to use an experimental retain{} API. In this article, you’ll dive deep into the internal mechanisms of retain{}. medium.com/proandroidde...

✨ New UI recipe Glitch effect used in a disappearing animation #JetpackCompose Code available here: www.sinasamaki.com/glitch-visib...

✨ New article on how to create futuristic, cyberpunk glitch effects that's overused in sci-fi movies, right in #JetpackCompose www.sinasamaki.com/glitch-effec... This approach uses regular canvas functions, so no need to dip into shader code... yet. #ComposeMultiplatform #AndroidDev

LazyList background composition. Starts first composition on a background thread via prefetch then finishes on main when the item shows. I like it. RN async lists often show gaps when you fling fast. Compose keeps layout and draw on main so it feels steadier. Curious and nice ok

Realtime Blur on Android used to be a punchline, and many of us still carry that muscle memory. This thread rewrites it: what we tried, why it hurt, and how RenderEffect + AGSL made "frosted glass" practical and fast. #AndroidDev #JetpackCompose #Shader #AGSL

Wrote a quick blog post about the newest AndroidX library 'androidx.text:text-vertical' 📚✨ Learn about the cool functionality this provides and why this is important, particularly if you read Japanese newspapers 🇯🇵📰 Read more: www.spght.dev/articles/13-... #AndroidDev #AndroidX

These results come directly from the version of the library in the project, not web search, not training data, but exact functions from the real dependency source code. @androidstudio.bsky.social already has MCP support, and I'm really hoping it will one day provide this kind of info too. 😊

I built a Gradle plugin that generates Kotlin LSP workspace configs, enabling Android development in editors outside Android Studio. Recently I added a side feature: it also builds a search index for an MCP server I put together. #AndroidDev

For a moment, it felt like the calendar had rewound to 2010. 😅

Hopefully, a future Android Studio update will make it possible to modify the host field instead of having it hardcoded to localhost. This matters for my setup because I work on my laptop, but I run LLMs on a dedicated powerful machine in my local network ☺️ #AndroidDev

Open-sourced my Android-in-VS-Code experiment. A Gradle plugin that generates workspace files for Kotlin LSP. Many things don't work, but some do 😅 github.com/desugar-64/k... #AndroidDev #VSCode

Android #JetpackCompose project in Visual Studio Code using the official @kotlinlang.org LSP. 😅

Spent a few evenings tinkering with the official KotlinLSP. Got it working with Android in VSCode by writing a custom Gradle Plugin to analyze classpath & generate workspace.json file. Now I have auto-completion for Android libs/SDK + basic build & run tasks. Loving the progress! #AndroidDev

I can’t believe this just happened, I didn’t expect it so soon! You can now specify your own LLMs for the Android Studio Coding Agent. This is huge! 🚀 #AndroidDev developer.android.com/studio/gemin...

ScrollView had a very odd scrollbar with almost no customization, and I don’t recall ever leaving it enabled. Nevertheless, Compose is the best thing that has happened in Android dev: an unbundled, first-class UI toolkit that can be updated as a project library rather than through an OS update.

Combining path animations and cube rotations for this magical reveal effect ✨ #JetpackCompose #shipaton #buildinpublic

I tried the new shape-morphing APIs and found them easy to use, with great-looking results. #AndroidDev #JetpackCompose

🚨 New video alert!! Learn all about how to combine Shared elements with Shape morphing in this #ComposeTip www.youtube.com/watch?v=0moE...

🧊 3D cube in #JetpackCompose No model, just some matrix transformations applied on the UI Cooking this for my #Shipaton project

I'm really liking where this is going, the overall shape is starting to take form. There are still some rough edges, but the work is progressing nicely. #AndroidDev #JetpackCompose

In Compose, the slot table contains notes about what happened during composition, what was called, what parameters were used, etc.. It is where values are remembered and you can think of it as a method trace of the composition 🧵

The topic is important, but the article feels a bit light on technical depth. It mostly discusses why it matters, how to measure it, and some high-level actions they took. I was hoping for more low-level insights, like timeline analysis or even bytecode disassembly to really dive into the detail.

Key tips for handling bitmaps efficiently in Android: – Use sample size when loading – Implement bitmap polling – Use RGB_565 for non-transparent images at scale (½ memory) – Monitor memory during development #JetpackCompose #AndroidDev

How to display many high-quality images at once without OOM? Use atlas textures: – Pack multiple images into a single bitmap – Draw specific regions via coordinates One texture = lower memory overhead than managing hundreds of bitmaps. #AndroidDev #JetpackCompose

Hey chat, what do you think of these animations? Are they a bit too distracting? #JetpackCompose #AndroidDev

📢 Android NDK r28c is out! - Updated Clang (r530567b/c) - Smaller disk footprint - libc++ ships with debug info - 16KB pages default on arm64/x86_64 - libclang & weak libc refs added Check it 👉 github.com/android/ndk/... #AndroidDev #NDK

As Jetpack Compose evolves, so does Compose Multiplatform! The brand new dropShadow and innerShadow modifiers are now available for multiplatform with the 1.9.0-alpha03 release! Learn more about the APIs here: issuetracker.google.com/issues/16066...

That said, note that sometimes using a texture is necessary (overlapping alphas and various other effects). Thanks @romainguy.dev for clearing this up 🙏 you are the bible of performance.

But this costs RAM, bandwidth, and if the layer changes frequently you may end up doing the work twice (regenerate the texture, then copy the texture on screen). 🔔 And textures obviously won't look good if zoomed with very big or very small scale factors for instance.

Now on top of this, offscreen graphicsLayer are an extra level of caching, where all the commands of the RenderNode are issued to the GPU to capture the result into a texture. On subsequent draws, the only command sent to the GPU is "draw this texture”, fast and efficient.

RenderNodes exist to save CPU time, not GPU 🧐 The GPU will do the same amount of work, but the CPU will do less since the drawing commands do not need to be generated again, but the whole block (list of commands) is reused.

In LazyLists for example, when scrolling, all the UI toolkit has to do is change the Y translation transform of each RenderNode, so no Java/Kotlin code has to run again. Just offset the already cached block of commands.

An example of this optimization in graphicsLayer 🎨 Using a graphicsLayer means a RenderNode is used to capture the drawing commands of each item. This is no different than what Views did.

When a chunck of UI (View or graphicsLayer) is associated with a RenderNode, the UI toolkit doesn’t need to reexecute the code that generates those drawing commands, but can instead reuse the entire list of commands ✨

What RenderNode really is 🧶 (thanks @romainguy.dev 🤩) They are a list of drawing commands with some other properties like transforms (e.g: translation). These commands can be used to issue GPU commands by the internal renderer. They are not GPU commands on their own.

By the way, @c5inco.bsky.social, maybe you know someone on the Android Developer Documentation team. Have they ever discussed anything like this or possibly have plans to do something similar? Maybe I should file a request to track it.

@c5inco.bsky.social Gemini CLI has such generous free tier limits. I hope this is something we as Android Studio users also get bumped up for in Agent mode soon. Right? 👀 #AndroidDev

Ice cream Chrome 🦖 #GoogleIOConnect #Berlin