That’s how Compose Loaders was born.

Grab them here:
https://composeinternals.com/composeloaders 🚀

Take a moment to share this tweet if you want to help me reach more people. This project is 100% free. Enjoy and thanks!

I’m pretty happy about this one! so wanted to share it with you.

Feel free to use it and give me some feedback, it will be really appreciated ❤️‍🔥🙌

Why I created it

Every week there’s a new AI model, a new tool, a new workflow. It’s really exciting but also very overwhelming. It’s easy to fall into analysis paralysis and spend more time reading about AI than actually using it.

That was my feeling too, so I decided to create a small limited community where we can stay focused on learning and building. Think of it like a study group. A group of people interested in the same thing, sharing ideas and projects. When you narrow the scope and have people to experiment with, it becomes much easier to stay focused and start moving. We can call this “hyper focus”.

This is why thedroid.club exists. It is a closed Discord community of Android devs tinkering with AI to become more proficient, and build tools that push the entire ecosystem forward.

It’s limited to 500 members. Seats open in batches of 50, and the price goes up with every batch. Keeping it small makes it easier to control the pace, the projects, and the initiatives inside the community.

The Droid Club is a closed, invite-level Discord community for Android developers who want to explore, tinker, and create with AI. The people inside are building the tools, workflows, and experiments that will define what Android development looks like next.

The product is the people. Direct access to developers who are as obsessed with this intersection as you are. No fluff channels, no lurker armies. A war room where every member is here to play, build, and push things forward.

⚠️ Hard-capped at 500 members. Sold in batches of 50

Each batch has a fixed price. When it sells out, the next opens higher. The price you see now is the lowest it will ever be. Once all 500 spots are claimed, the door closes. No exceptions.

• Founding 50 - $99 - 12/50⏳

• Batch 2 - $129 - Next

• Batch 3 - $149 - Next

• Batch 4 - $179 - Next

• Batch 5 - $199 - Next

• Batch 6 - $229 - Next

• Batch 7 - $259 - Next

• Batch 8 - $299 - Next

• Batch 9 - $349 - Final

What you get:

• Lifetime access to the private Discord: A curated room of Android devs exploring AI models, creating tooling, skills, MCP integrations, prompts, automation, GitHub actions, code generation, and literally anything we find interesting.

• Free license to GreenClaw (greenclaw.io): included with your membership 🦞 put your old Android devices to work!

• Periodic community activities: Brainstorming calls, live builds, experiments, teardowns, and collaborative sessions organized by and for members.

• Direct access to the people who are figuring this out: The aim is to get a high quality group of people interested on this topic. Use this chance to get in. Ask questions, share discoveries, find collaborators, get unstuck. The value is in the conversations you can’t have anywhere else.

• Where the cool kids are: I’ll gradually invite some familiar names from the Android community. You’ll have direct access to them and get to build with them.

Who this is for:

Experienced Android developers who are genuinely curious about AI and want to tinker, not just watch. You don’t need AI experience, you need the drive to explore and build alongside people doing the same.

Who this is NOT for:

People looking for a course or passive content. This is a community. You get out what you put in.

One payment. Lifetime access. No subscription.

Early batches get the best deal. Each sold-out batch raises the price for everyone who comes after. There are no discount codes, no sales, no “wait for a deal.” What you see right now is the cheapest it will ever be.

500 Android devs building the future of the craft with AI. Use your chance to get in, or get left behind.

Join thedroid.club 🧪

This new Google Play requirement is a big showstopper. Getting 12 real testers to test your app for 14 days continuously is not an easy matter, especially if you don’t have a big audience.

But Google enforces this to publish any app to production now.

Since this is a hard blocker, I decided to try to solve it and created a platform to do it for free. You test apps from others, and in return you get credits to list your app and get it tested. Everyone wins. Android devs healping each other to meet this requirement ❤️‍🔥

The way it works:

• You sign up and join the tester list for any app listed.

• You test the app for 14 days. There are 5 checkpoints where you need to give feedback, one every few days.

• App owner rates your feedback, you get some credits back (4 per checkpoint, 20 per app fully tested).

• Listing your own app costs 60 credits, so testing 3 apps gets you there.

• You can test multiple apps at the same time, so you can earn enough in a single 14-day cycle.

• At the end you get a full report with a guide to apply to production.

The feedback is actually useful too. It’s organized by feature and checkpoint day, so when you go to fill out Google’s production access form, you have real numbers and specifics to reference instead of making stuff up.

We also generate pre-filled answers for that form based on your testing data, so you can just copy and paste them in the Google Play console form when applying to production.

Feel free to give it a test get12testers.com. Since it is completely free and based on the credit system, all I ask for in return is some feedback. Let’s improve this platform together 🫶

Jorge.

Hey folks 👋

Quick personal share with you all, because this community genuinely means a lot to me.

I’ve just decided to drop the price of ScreenshotWhale by 50%, probably for a limited time. I’m not doing a big public push yet. I wanted to mention it here first, because you’re the people I actually care about getting value from it.

I built ScreenshotWhale because I kept hitting the same wall myself:
I love building apps, but screenshots always felt like a chore. I wanted something that helps devs ship clean, consistent App Store / Play Store screenshots without needing design skills or a designer.

If you’re working on an app, shipping something soon, or just tired of wrestling with screenshots, this might genuinely help you:
👉 https://screenshotwhale.com

No pressure at all. Just wanted to share it with you because this community has always been supportive, thoughtful, and honestly one of the best groups of Android devs I know ❤️

If you try it, I’d love to hear what you think.

Most developers don’t have a designer eye, and that’s completely okay. I’ve seen this in many devs that I had the chance to work with in the past. I also suffer from that a little bit.

Personally I enjoy building products, thinking about architecture, performance, testing, automations, user flows, design patterns... and what not. But design has never been my best strength. I’m probably a more technical type of dev.

When the time comes to create App Store or Play Store screenshots, this gap shows quickly, and makes me waste so much time. My problem is not effort or care, I can tell you that. It is rather a mix of a lack of design skills, experience working on design, and some guidance.

I recently found myself actively thinking about how to solve / shortcut this problem more often. So unsurprisingly, I decided to build a brand new product 🙈

I felt that gap is precisely where a drag and drop editor with bootstrapping features would start to make sense. It is much easier when you have a quick way to kick off your screenshots and start from a much more polished / professional point.

This product started as something I created for myself. I added an online screenshot editor with support for several screen ratios and form factors (including weareables), and I used it to create some templates. then I added those as an entry point to the platform, so whenever I needed screenshots for a new app I would just grab one of the templates and start iterating from there.

After that, I added support for AI powered generation, so you could grab your in-app screenshots and generate a fully working project in the editor using some predefined layouts (text above and mockup device below, text below with mockup device above, etc). That gave me speed without losing any control, since I could iterate on them after generation.

The product evolved so fast. I kept adding more templates and features, which allowed me to create even better / more professional templates later on. I also added automatic internationalization to the project.

At this point it just made sense to open it to the public. I gave templates a price, added subscriptions, and added some FREE templates so users could try the product for free and decide later if they wanted to pay for access to all templates and more powerful features.

I wasn’t trying to design something beautiful or perfect from scratch, but rather something functional and helpful. I was playing, having fun while building, and just working on features that help me avoid my most common mistakes.

Turns out creating this platform made a significant difference for me. Screenshots became way quicker and more consistent / better looking. Updates were easier too, streamlined. I could iterate without second guessing every decision, and without much trial and error anymore.

Anyway, the platform already made its first 100 users 🥳 which I am very proud of. And this is just the beginning!

If you want to try it, you can find it in ScreenshotWhale.com and pick one of the FREE templates to start. Let me know what you think!

P.S: Sometimes you don’t need to become good at something, just have the right tools!

That sounds great and motivating, but one big bottleneck still remains: App Store Screenshots.

Creating professional high-converting screenshots for the stores is a thoughtful process that requires some design skills, lots of time and later iteration, especially if you want to support multiple languages. It is still a distracting process from what matters most for you: shipping and validating your product in the open.

For that reason I have added SmartShots AI to ScreenshotWhale (🎥 Watch the video above to see it in action)

SmartShots AI lets you generate high-quality App Store screenshots with a single click in a matter of seconds, and you keep full control after generation: It adds the generated screenshots to a new project that you can iterate on whenever you want.

You just upload your screenshots, click generate, and let the platform do all the heavy lifting.

🌍 Automatic AI-powered internationalization

Your screenshots are localized automatically during export, helping you reach global users without extra effort. This can also be a huge time saver.

Subscription update

SmartShots AI is included in the monthly subscription, which is now available as an alternative to the lifetime plan. Save some precious time and focus on what matters most: shipping.

50% COUPON FOREVER 🔥💸

Use the coupon EFFANDROID50 to subscribe with a 50% discount to the platform. Save some money and start shipping today, no more excuses!

Subscribe with a 50% discount

Ace your next Android job interviews in 2026, focus on truly understanding the concepts, not just memorizing answers, and practicing how to apply them. With 108 interview questions, 162 additional practical questions, and 50+ pro tips, this book helps you sharpen skills, understand the why, and prepare for real-world technical challenges.

Get it here with a big discount until XMas day!

Jetpack Compose Internals cohort course 👨‍🏫

Award-winning Jetpack Compose course ⭐️⭐️⭐️⭐️⭐️

Master Compose internals, advanced techniques, best practices. Created and delivered by Jorge Castillo: Disney+ engineer, ex-Twitter (X), author of the Jetpack Compose Internals book. Jorge has led several Compose initiatives on big tech companies.

Includes the Jetpack Compose Internals book for FREE.

Get it here with a big discount until XMas day!

Jetpack Compose internals book 📖

The most known Compose book out there. This is the only book that lets you deeply understand Compose by diving into its internals. An absolute game changer. Master how Compose works internally and become a more efficient developer with it. This book provides all the details to understand how the Compose compiler & runtime work, and how to create a client library using them.

Get it here with a huge discount until XMas day!

I like sharing high quality and exclusive learning resources that go beyond surface-level tutorials. Whenever creators in the Android community release something truly valuable, I try to bring it to you early and for a cheap price. Often with special discounts or insider access. This week is one of those moments! 🙌

30% off for up to 50 people
👉 https://leanpub.com/manifest-android-interview/c/DbnjFsH5t1s2

What the book gives you
108 interview questions, 162 extra practical questions, and 50+ pro tips. The goal is to understand Android concepts deeply, not just memorize answers. It helps you sharpen your thinking and prepare for real-world technical challenges. Absolutely worth a read!

New project: Compose Stability Inference
This is Jaewoong’s latest deep dive into how the Compose compiler determines type stability to optimize recomposition. Repo: https://github.com/skydoves/compose-stability-inference

This one is an absolutely masterpiece full of knowledge, I promise.

Highlights at a glance

• Full stability type system

• Decision trees and inference algorithms used by the compiler

• Bitmask encoding and $stable field generation for generics

• Compiler phases that influence skipping and performance

• Reports, configuration files, and annotations to inspect and control stability

• Case studies for data classes, generics, interfaces, and inheritance

• @Stable vs @Immutable explained with real performance implications

If you want to level up both your Android interview prep and Compose performance knowledge, grab the discount and give the repo a ⭐

This post is a great chance to expand on some of the class stability inference topics we discussed in the Jetpack Compose Internals book.

Enjoy these awesome resources!

Jorge.

A lot of Android developers tell me they’ve thought about writing a technical book. Almost all of them also say they never found the bravery to start.

I know exactly how that feels. When I first thought about writing Jetpack Compose Internals, the doubts were all there: “I don’t have enough time,” “What if no one buys it?”, “I should probably wait until it’s perfect.”. Imposter syndrome was all over the place too. All those doubts refrained me from starting.

Publishing Before It Was Finished

The problem was, Compose 1.0 stable was around the corner. If I wanted my book to matter, it had to be out that same day. There was just one issue: the book was barely started.

Instead of following the “normal” path of disappearing for months to write a complete manuscript, I decided to publish early. Really early. The idea was simple: release the first version with only part of the book written, then update it gradually. Every time I published new chapters, readers would automatically receive them. I only needed to find a platform that would allow me to do that, and that was Leanpub.

This decision solved two critical problems:

1. I could launch on time, right when Compose was making its big splash.

2. I would know immediately whether people actually wanted the book.

Immediate Validation

Publishing half a book felt risky. But it was the right decision. As soon as I put it out there, sales started coming in. That was the clearest validation I could get. Developers didn’t just tell me they were interested, they proved it by paying for it. That is particularly important since public opinion and comments can be very misleading, and often not reflective of the actual demand. People often comment just to engage.

I was able to surf the Compose release wave and got a lot of early traction. That early response gave me the energy to keep going. I had people waiting for the next chapters, which turned writing into a cycle of feedback, updates, and momentum.

Launching at the Right Moment

On the exact day Compose 1.0 stable was released, Jetpack Compose Internals was out too. That timing made all the difference. Developers were hungry to understand how this new framework worked under the hood, and the book was there to fill that need.

The revenue numbers:

• - Around $15k in the first month

• - Later stabilizing at around $2k per month

• - Even today it still makes $500 to $1k depending on promotion

• - Total revenue around $70k today

This is how tech books normally behave. You can be lucky to get a viral boost at launch, especially if you have a good strategy and timming. Maybe some months after if too. But after that, it’s down to consistent promotion and SEO. If you stop talking about it, people simply stop buying. That is something that I have learned during this journey.

But the real win was not only the money. It was the credibility, visibility, and trust that came from putting something useful into the hands of the community. I could really grow myself into an authority on the topic, while I was also learning deeper and deeper about it. That also paid off with the course, where I could expand the content and go deeper into all the topics.

Not working with a publisher

I also chose not to work with a publisher. That would have slowed me down, taken away all control, and cut too deeply into the revenue. I wanted to cut all possible edges and take full control of the process. Only that way I could ensure that it was released right in time, that the challenge was worth it, and that I would be able to keep it up for the long term. Something to note here is that this was only possible because I already had a big audience and a lot of trust from the community. Otherwise distribution would have been a huge challenge.

By handling it myself, I decided on the timing, the pricing, the positioning, and also the updates. It was more effort, but it meant I owned the whole process.

What Other Developers Can Take Away

If you’ve been thinking about writing a book but never started, here’s what my experience taught me:

You don’t need to wait until it’s finished. Start small and build it in public. Every step and every bit of knowledge you share compounds.

You don’t need to be perfect. Readers value progress, but especially honesty. As long as you are clear about it not being finished, people will still jump in if the content is worth it.

You don’t need to ask for permission. You can take full control of the process if you want to.

What really matters is timing. Catch the right wave and ride it.

Final Thoughts

Writing a book sounds overwhelming, but it doesn’t have to be. You don’t need to lock yourself away for a year to produce a polished masterpiece. That would actually be a poor business decision. Any project needs to be validated early on, before investing too much time into it.

You can release early, validate demand right away, and grow it step by step while readers come along for the journey. You will gather feedback and be able to iterate on the content as you go, aligning it much better with the actual demand.

That is how I wrote Jetpack Compose Internals. And if you have been hesitating to write your own book, maybe this is the approach you need too.

The bravery comes after you start, not before. Just start. You will learn a lot by doing it, and the process will get easier as you go. Our brains are wired to learn by doing, not by reading. Analysis paralysis fades away as soon as you start.

Some words for the people who joined the newsletter these days.

This new AI vibe coding era is crazy. People are building apps blazing fast. I have been doing it myself for a while lately and the code does not look great 😂 (no point on lying!!), but the end result is actually pretty good. User experience is smooth and the apps don't have significant bugs either. You keep getting better with the prompts.

One of the biggest caveats I find now for quick iteration is to get the apps finally released to the stores. That final bit takes lots of time and AI does not solve it well (yet?). Especially creating the screenshots. That is probably one of the most time consuming parts I suffer myself. And it is not something you can just skip. Screenshots don't do magic, but can give you a big boost in downloads, especially when it is a new published app.

I thought it would be great to create this service so people could generate their app store screenshots super quick but without compromising quality (that is normally the issue with all the AI generated slop out there today). I also wanted it to be actually useful. That is how I created ScreenshotWhale 🐋

The end goal of app screenshots is to highlight the value your product brings, not just pile up a list of features. You want emotional connection for more impact. The simplest way to tap into emotions is by showing clear problems and how your app solves them, using relatable visuals people instantly relate to, like photos or illustrations. This is the main thing I want my product to solve. Not easy! but hopefully it does.

It has its own layer-based editor (Figma style) and runs in the cloud, so you don't need to mess with save files yourself. I has a bunch of high-converting professional templates crafted and curated by me with lots of care 🫶. It supports multiple device types, form factors, phones, tablets, wereables for both Android and iOS. And it has super quick automatic internationalization (i18n) during export, so you can get your screenshots automatically translated to all the languages you need.

It is in the initial stages now, so any new users are obviously more than welcome, especially to gather feedback and iterate it towards the audience needs. Would love to hear your thoughts, so feel free to check it out: screenshotwhale.com. There are FREE templates in there too! 🐋 📸 📲

The wait is finally over. ScreenshotWhale is live today 🎉

Many of you have been following this project from the very beginning and I honestly couldn’t be more excited to finally open the doors. This stage is particularly important and your feedback will be gold for shaping what comes next.

Some of the things that ScreenshotWhale already offers today:

• ✨ Creates professional, high-converting screenshots in minutes.

• ✍️ Has its own fully-fledged online editor.

• ☁️ Runs in the cloud, no need for saving your own project files somewhere else.

• 🎨 Polished professional templates crafted by me, adding new ones every day.

• 🌍 Automatic i18n to multiple languages on export.

• 📱 Support for iOS, Android. Multiple form factors, even wereables.

• 🔄 Mirror feature to replicate edits across form factors instantly.

• ⚡️ Quick-start settings for most common app store layouts.

• 🧩 Layer based system. Support for text, image, mockup devices, backgrounds and other types of layers.

And this is only the beginning. I am iterating fast and plenty of new features are already lined up.

👉 Jump in at screenshotwhale.com and start building your new app screenshots 🐋

Thank you so much for being here from day one. Your support means the world 💙

Some sneak peek screenshots below for context 👇

Jorge.

Become part of my journey (and earn along the way)

Today is the day. I finally enabled the affiliate program for Compose internals 🥳

When I first started writing about Jetpack Compose, I had no idea it would change my life this much. What began as curiosity turned into a book, then a course, and now a growing community of Android developers learning, building, and supporting each other.

I shared my full story a few days ago. It has been such a rollercoaster since then 🤯. Many devs reached both in public and in private saying that my post inspired them to keep fighting to meet their goals. Keep rocking!

I’ve always shared my work openly because I know how motivating it is to see others succeed. And now I want to give you a chance to be part of that success 🙌

I just opened the affiliate program for my Jetpack Compose Internals course. That means if you share the course with your audience, friends, or community, you can earn up to 20% from every single sale. As simple as that.

I want to be 100% honest with you: I do this to make Compose internals grow even more. No point on lying. But it is also about joining me in something bigger: helping Android devs everywhere understand Compose on a deeper level (that is my personal crusade), while creating a new side income stream for yourself.

Creators, bloggers, YouTubers, community leaders, or just passionate developers, this is your shot. Others are already joining, and the earlier you jump in, the bigger your impact will be.

The number of affiliates I will accept in the program is going to be limited for now, I need to keep some control on it. First come, first served.

👉 Sign up as an affiliate here

I can’t wait to see you on the other side!

Jorge 🫰

Several people asked for PPP recently. I had some issues to enable it but it should be working now. I enabled two things:

• Purchasing Power Parity (PPP) - Charge customers different amounts depending on the cost of living in their country.

• Pay in 2 installments

Enjoy, and thanks for all your support as always!

When Android developers think about side income, the usual answers are freelancing, consulting, or building a small app to monetize. I went in a different direction. A slower one at first, but one that snowballed into something bigger than I expected.

It started with me just sharing thoughts online, with no clear plan. Over time that turned into a book, then a course, and eventually a consistent income stream. Here's my full story.

Years of Sharing and Showing Up

For 10+ years I had been posting Android tips, opinions, and code snippets on X (previously Twitter). Nothing polished, just honest takes from my day-to-day work. I normally tried to have a critical mindset and expose my honest perspective on things when I found it valuable. And a little bit of raging from time to time as well!

I also spoke at national and international conferences like KotlinConf, Mobilization in Poland, and many others. Started small, then went for bigger events. That helped me reach new audiences, connect with devs around the world, and position myself as someone others could rely on for valuable Android content.

I didn't have a product in mind. I just liked to share what I was learning, both online and on stage, and over the years I grew a good sense on identifying what topics people were most interested in. But these things compound. Consistency + visibility builds trust. By the time Jetpack Compose came around, I already had a public image as someone people turned to for Android knowledge.

That was the foundation for everything that followed.

The Jetpack Compose Moment

Then came the announcement of Compose alpha 🙀

I'm sure I was not the only one, but I could immediately see how big it was going to become. Coming from my previous experience building sites in React, the parallels were obvious: declarative UI, smart diffing, state-driven rendering, lifecycle-aware effects... It was the same mental model all over again! but this time adapted to Android. And the fact that part of the original Compose team had worked in React before made it even more obvious.

It was clear to me: Compose wasn't just another library. It was the immediate future of Android UI, and every company would eventually migrate, inevitably. The only question was how soon.

That's when it hit me: if this was going to redefine Android UI development, then there would be demand for people who really understood it deeply.

On top of this, I also knew that diving into the internals of the View system had been a huge leap forward for me in the past. I knew that offering the same perspective for Jetpack Compose would help others as well.

Writing the Book

Only a few days after the first Compose alpha release, I had already subconsciously made the decision to write Jetpack Compose Internals. And I wanted it to go deeper than just "how to use Compose." I wanted to explain how it worked under the hood, and help people to use it correctly and efficiently.

But timing was everything. I made it my goal to release the book on the exact day Compose 1.0 stable dropped. If Compose was going to make a splash in the industry, I wanted my book riding that wave. But I had a significant problem: The book was just barely started and there wasn't enough time to finish it.

To make it possible, I chose Leanpub. This platform would let me prelaunch the book with only part of it written, then keep delivering updates. That would allow me to hit the deadline without compromising the quality of the content.

Finally, I decided to not work with a publisher. Why give away a big cut when I could do it all myself? Writing, editing, promotion... yes, it was more work, but the audicence was already there, and it also meant full control for me. Publishers take a huge cut from authors today, to the point of making the deal very unfair.

Launch and Positioning

The strategy worked. On Compose 1.0 launch day, my book was out too. That timing alone positioned me as "the Compose guy" overnight. I became the go-to reference for anyone looking to understand Compose internals.

Numbers were great for such a niche book: First month revenue was around $15k 🎉.

After that, sales dropped gradually every month, and ended up stabilizing around $2k per month for quite a while. This was a huge motivation boost for me to keep writing what I wanted to be the best Compose book in the market.

Even years after that, it still brings in $500–$1k per month, depending on how much I promote it.

This is how normally tech books behave. You can be lucky to get a viral boost at launch, especially if you have a good strategy and timming. Maybe some months after if too. But after that, it's down to consistent promotion and SEO. If you stop talking about it, people simply stop buying. That is something that I have learned during this journey.

Proof the Bet Was Right

Fast forward to today: Compose is the standard for building Android UI. Companies across the world are migrating. Almost no teams out there are sticking with the View system anymore.

That decision I made back in the alpha days proved to be the right call. And that's the thing with tech trends: if you catch them early, you can ride them for years.

Promoting It Myself

One myth to clear up: no product "sells itself". There might be some exceptions, but in general that is really hard.

Yes, I had great timing. Yes, the topic was hot. But without me actively promoting the book on X, on my newsletter, and in other social networks, it would have faded out much faster.

Promotion is a continuous job. It doesn't feel glamorous, can be boring, but it's the difference between something dying after launch and something that keeps paying back.

Expanding Into a Course

The book was a success, but I knew not everyone learns from books. I also had some good skills giving technical courses that I acquired when working as a trainer for another company, so I decided to build a course and expand on all the topics in depth. My mindset on this was to not create a course that would barely scratch the surface, or just recap the book, but to go even deeper and cover all the topics in much detail. I really wanted it to be useful and worth for people to pay for.

I also decided to make it a cohort in the first place: I would record all the content, provide a support channel for doubts and interesting conversations, and deliver it over several weeks in a structured way. That would allow me to expand the content so much and explain all the topics as clearly as possible.

I built the ✨ Jetpack Compose and internals cohort-based course ✨. And it absolutely blew up. It was an absolute madness that I can't even believe to this day, honestly. Total revenue ended up at around $183k 🤯🫣

Read the full story 👉 https://composeinternals.com/how-i-made-side-income-from-jetpack-compose

I haven’t revealed much about StoreShots yet, my new service to generate gorgeous Play Store and App Store screenshots.

Starting today you can early preorder and get:

🔥 Lifetime access at 50% off (will cost $149 once released)

🚀 Early access a few weeks before launch, before everyone else

✅ Full access to all available templates

⚡ Offer available for a limited number of people and for limited time.

Let’s build this together and make it the best screenshot generation service out there 🙌🚀

Preorder lifetime access

When I started writing code, it wasn’t because of money, prestige, or even a career plan. I just loved building things. Especially things I could see come to life on a screen. Little mobile apps, simple websites, side projects that felt like magic the moment they worked. Hitting run and watching an idea appear in front of me was addictive.

I still remember the first time I managed to make a network request from an app. Until then, the code I wrote felt like it lived in its own little box. The moment it connected to the outside world, everything changed. Suddenly I could imagine multiplayer games, dynamic apps, live updates. It felt like a new universe opening in front of me.

Salary was never part of the decision to become a developer. At the time, programming wasn’t even that well paid. The startup boom and the big tech salaries came much later. For many of us it started with curiosity, joy, and the challenge of making something real.

Looking back, I realize how lucky we were. By coincidence, the industry exploded and we happened to be there, doing something we already loved, right when it became valuable. If things hadn’t gone that way, I honestly don’t know what I would be doing today.

I think it’s good to remember this sometimes. That what pulled us in at the beginning wasn’t the money or the hype. It was the thrill of creating something out of nothing. And that is still the best part. 🫶

Follow me in social networks

• Find me on X

• Find me on LinkedIn

• Find me on Bluesky

Book the Compose Internals course: 7 weeks worth of content for the cheapest price ever 🔥

Stop Chasing Recomposition Counts 🧠📉

I just dropped a short video that tackles a common trap in software development: focusing on the wrong metrics.

Too often in Jetpack Compose (and dev in general), people obsess over recomposition counts… but forget to ask the real question: is the app actually slow? Performance is about outcomes, not internals.

In the video, I break it down with a simple example and show why you should focus on end goals when optimizing your code.

My best advice here is: learn about macrobenchmarks, get familiarized with them and write some for your product.

🎥 Watch it here:

@jorgecastillo.devFocusing on end goals 🎬

Tiktok failed to load.

Enable 3rd party cookies or use another browser

I have decided to go Full Video mode, so we can adapt to the times! 🚀

I’ve finally launched my TikTok and YouTube Shorts channels. I’ll share experiences and reflections as a developer, everything I know and I have learned about Android, productive tips, dev stories, behind the scenes, and the stuff nobody wants to tells you.

Essentially whatever comes to my mind that feels worth to share with you folks 🙌

Quick and practical.

If you want to help me speedrun the algo, since it can be a bit complicated in the new beginnings, please consider giving a follow if it is not too much to ask. I’ll be more than happy to have you on my network 🫶

🎯 Follow here:
🔹 TikTok → jorgecastillo.dev
🔹 YouTube Shorts → JorgeCastilloDev

Let’s make Android dev content fun again 😬
See you there! 👋

(Thanks @romainguy for clearing up these details 🤩)

RenderNodes are a fundamental part of how Android's UI rendering works, both in traditional Views and in Jetpack Compose. Understanding how they work can help you write more performant UI code and make better architectural decisions.

In this post, we'll explore what RenderNodes are, how they optimize rendering performance, and why they're so important for efficient UI rendering on Android.

What Are RenderNodes?

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

When a chunk 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 ✨

This reuse mechanism is one of the key performance optimizations in Android's rendering system.

RenderNodes in graphicsLayer

An example of this optimization can be found in graphicsLayer 🎨

Using a graphicsLayer means a RenderNode is used to capture the drawing commands of the involved items. This is no different than what Views did. The key benefit is that once the drawing commands are captured in a RenderNode, they can be reused without regenerating the commands from scratch. Let's see an example of this in LazyLists.

Performance Benefits in LazyLists

Read the full post in 👉 https://composeinternals.com/rendernode-in-android