Serhii Yaremych

Generated Image of Chet Haase as a saint

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

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

Everything’s relative, context matters. To me, game dev often runs harder than mobile or even C++ systems: realtime demands, engine guts, content pipelines, netcode endless edge cases. In the end its time invested tools click, fluency grows. No shade, respect to every craft. Experience shifts slope.

The next thing they need to do is make the debugging experience better than just printing lines to the console. Currently, step debugging isn’t possible from Android.

This is def not a normal situation - most libs have consistent alignment across all pages, which is prob why AS only checks the first one.
But edge cases exist, especially w/ external native deps. Better catch it now than scramble on Oct 31st when everyone panics lol. Stay safe!

Don't rely only on AS. Use readelf from NDK directly. Check ALL LOAD segments.
The "Align" column must be 0x4000 (16KB) or higher for every single one. Even one segment showing 0x1000(4KB)?
That's ur problem right there.

We updated all our native libs to be compliant. Android Studio showed everything's good.
But Play Console kept warning us we're still not compliant. Spent forever debugging, turned out one of the libs had its last page aligned to 4KB instead of 16KB. Super not obvious.

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

android-review.googlesource.com/c/platform/f...

3695306: Reimplement SlotTable as a link table | android-review.googlesource.com/c/platform/f...

It looks like it hasn’t been merged yet.

It’s no longer a gap buffer, in the recent release, it was rewritten into a linked list–like structure.

The next iteration will involve stripping "Android view" from the codebase. 😅

Not really “just a Flutter”. Technically Compose is more advanced and does a better job automatically diffing state changes and updating widgets granularly. On Android it doesn’t carry its own renderer but embeds into the native Canvas, which has both advantages and disadvantages.

So for me it’s just the JVM style. Lots of small explicit pieces instead of one umbrella module.
Android Studio smooths over and hides a lot of the import shenanigans, but outside AS, every time I hop into VS Code for a quick fix, I feel that pain.

Fair observation. For example, in Compose, modifiers are extension functions spread across packages, so the imports pile up. Android Studio auto-import hides it, but turn it off or write in VS Code and you feel every missing piece immediately. pretty quickly.

GitHub - skydoves/compose-stability-inference: 📚 A comprehensive study of how the Compose compiler determines type stability for recomposition optimization. 📚 A comprehensive study of how the Compose compiler determines type stability for recomposition optimization. - skydoves/compose-stability-inference

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...

Understanding retain{} internals: A Scope-based State Preservation in Jetpack Compose Jetpack Compose is a modern Android UI development with its declarative approach and powerful state management primitives. While remember{}…

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

AGSL: Made in the Shade(r) RenderEffects #2: Pixel shaders in Android 13

Don't be afraid to experiment. The Android rendering pipeline is far more flexible now: RenderEffect for sane defaults, RenderNode/graphics layers for backdrop control, Haze for convenience, AGSL for custom algorithms. The only real limit is imagination.

medium.com/androiddevel...

GitHub - Kyant0/AndroidLiquidGlass: Jetpack Compose Liquid Glass library Jetpack Compose Liquid Glass library. Contribute to Kyant0/AndroidLiquidGlass development by creating an account on GitHub.

We're no longer limited to Gaussian blur. You can implement custom blurring algorithms, and developers have replicated LiquidGlass with AGSL. Since shaders are embeddable, the palette of effects is wide open.

github.com/Kyant0/Andro...

Android Developers Backstage: Episode 184: Skia and AGSL - Shaders of Things to Come In this episode we chat with Derek and Brian from the Skia team about Skia, pixel shaders, and the new “AGSL” API that lets you provide pixel shaders for advanced graphics effects, which was recently ...

Android 13 answered with RuntimeShader and AGSL. You can embed small shaders directly into the rendering pipeline and drive them via RenderEffect, expressing custom filters as code rather than workarounds.
adbackstage.libsyn.com/episode-184-...

Once backdrop blur is in place, design asks grow: shaped or masked regions, adaptive intensity, chroma-preserving blur, and non-Gaussian looks that react to scroll. That's when you begin to outgrow the built-ins.

In Compose, the analogue is the GraphicsLayer API: it separates composition into layers so the background can be blurred as a unit while the overlay renders cleanly above. Prefer Haze by @chrisbanes.me — it handles this and edge cases.

In Views, use RenderNode for layered rendering: record background into a RenderNode, attach a blur RenderEffect to that node, then draw your translucent overlay afterward without the effect.

Backdrop blur with RenderEffect: separate layers. Blur the background layer, keep the overlay crisp, then compose them in order.

Applying RenderEffect.createBlurEffect(...) to a view gives content blur.
Useful, but it won't blur what sits behind your overlay.

Key distinction:
• Content blur: blur the pixels a view draws.
• Backdrop blur: blur the already-drawn scene behind an overlay (the classic "frosted glass").