Open-source frameworks are increasingly shaping the Android ecosystem, offering alternative solutions to Google’s standard libraries. This session will examine the practical benefits and trade-offs of adopting open-source frameworks at scale, addressing key gaps they fill and how they influence architectural decisions in mobile teams. >What is the current industry balance between open-source frameworks and standard Android libraries? >What challenges do state-machine architectures like Circuit, Workflow, and Appyx solve for mobile orgs? >How do open-source frameworks impact long-term maintainability, scalability, and team onboarding? >What are the key architectural bottlenecks in Android development today, and how do these frameworks address them? >trelWhat organizational investment is required to adopt, maintain, or contribute to open-source frameworks?

The Credential Manager API has seen significant adoption since passkeys arrived on the scene. Now, Android is taking user authentication to the next level by expanding support across the entire ecosystem, from phones and watches to cars and TVs. In this talk, we'll explore how the Credential Manager API is evolving to enable seamless and secure sign-in experiences on Android Auto, Wear OS, Google TV, and beyond. We'll dive into the latest API capabilities, showcase real-world examples of successful implementations, and demonstrate how you can leverage these advancements to simplify user journeys and enhance security in your own Android apps.

Android isn't going away, but your job might be. Your job, as it is today, is in danger. With the rapid changes in AI to allow more work to be done by a single developer, more technical and prototyping work done by product and management, pressure like we have never seen to do more with less staff, and the ever-increasing business, consumer, and leadership skills shifted-left onto you as a dev - it can feel impossible to stay relevant or feel capable. Then add KMP being the future of application development in ways that Flutter and React never could be as mobile development reaches market maturity, and you have some choices you need to make now. We can do this. You can do this. Together, we are going to talk about how to enact real change to provide value in your job, focus on your goals, architecture built for tomorrow, and balance adding technologies so that you are ready to maximize your impact or even just stay afloat.

Kotlin multiplatform is a great way to share new and existing Kotlin code with other platforms. But what about non-Kotlin code? Turns out Kotlin multiplatform can also be a great way to share code from other languages such as Swift, Rust, Zig, C, and more. This talk will show how to adapt code from these other languages into KMP, the restrictions and considerations when doing so, and look at some existing libraries which are doing this today.

The Jetpack Compose runtime and compiler together form the driving force of your composable functions’ execution and recomposition. This talk will unpack the black box of this duo and examine what magic is actually happening under the hood. Together, we will walk through a real-world example of a Composable function as it embarks on a journey through its initial composition and its first recomposition. In this talk, you will learn about the compiler’s role in transforming your composable function bodies, how the snapshot system invalidates your composition, how the runtime computes and applies the changes of a recomposition, and what a SlotTable is. Together, this knowledge will help make Compose feel less like magic and let you make more informed decisions about how to design your composable functions with performance in mind.

Sometimes you think you know coroutines, and then after a while, you’re like, “Wait, do I really know coroutines?” Inspired by the O’Reilly book _Programming Android with Kotlin_ and the upcoming new Droidcon eBook _Mastering Kotlin Coroutines: From Basics to Advanced _, this talk strengthens everyday coroutine understanding through playful explorations. You don't have to master coroutines to get started and be productive with coroutines. But when you walk out of this talk, you have deep understanding of coroutine mechanics and what tools can help you debug coroutine behavior. You might be in the beginning stages of learning Kotlin. Or maybe you’ve been using coroutines for a while and want to brush up, or maybe you're a little burned from other talks. Either way, you'll be looking at coroutines a little differently by the end of this session!

Dependency Injection (DI) plays a key role in building scalable software projects. The Android community has spent the last decade experimenting and iterating on DI approaches primarily focused on the benefits of facilitating testing and building more modular apps. If you weren't in the industry during that experimentation and iteration it can be easy to miss how we got to where we are today. In this talk, we're going back to basics! We're going to look at Dependency Injection, to help you understand the concepts behind the pattern, irrespective of which library, if any, you use to implement it. We'll look at the basic approaches to dependency substitution, see what problems DI can help solve, and learn how to make our own DI implementation.

This session explores how mobile teams can leverage their existing skills to create compelling XR experiences. With Android XR out and Project Moohan's release right around the corner. This is your opportunity to discover how mobile staples might be the industry's springboard into spatial computing, what challenges to expect, and how to prepare yourself and your apps for an increasingly cross-reality ecosystem. What is the current market landscape for XR on mobile platforms, and what trends or opportunities are projected for the next 2–3 years? What is the most common misconception among mobile designers and developers when considering a pivot to XR development, and how can businesses address it? What are the top tools, SDKs, and platforms that mobile developers should be looking at for XR projects? What unique design and UX challenges arise when building XR experiences for mobile devices? How can mobile development teams transition into XR development efficiently, leveraging existing skills and resources to minimize costs and learning curves? What's the most annoying parts about XR development compared to mobile? What are the most lovable parts about XR development compared to mobile? What unique advantages does XR development offer over mobile development that businesses can capitalize on to drive innovation or engagement? How do you see monetization and business models evolving in the mobile XR space?

AI is rapidly transforming the software development lifecycle, offering new ways for developers to build, test, and maintain applications more efficiently. From monorepo-aware coding assistants to agentic systems for large-scale code migrations, and from AI-generated tests to probabilistic agents reshaping quality strategies—this panel dives into the cutting edge of AI-powered developer tools. You’ll leave with actionable strategies for implementing AI in your own workflows, and practical ideas for driving meaningful productivity gains across your teams. >What does “AI-driven productivity” look like in practice across the software development lifecycle? >How can coding assistants be customized to work effectively in complex environments like monorepos or large codebases? >What are agentic AI systems, and how are they being used for tasks like large-scale code migrations or refactoring? >How is AI reshaping the traditional test pyramid—from the ground up with code generation, and from the top down with probabilistic testing? >What are some low-lift, high-impact ways mobile teams can start integrating AI into their workflows today?

Get answers to all your pressing questions in Q&A sessions with Google's Android DevRel team.

Presentation software is extremely powerful, full of creative styling, powerful animations, and plenty of other things. Yet every time I wrote a new presentation, I found myself repeating something with almost every slide; whether that be the content, styling, or animations. Wanting the torment to end (and a different kind of torment to begin), I wrote my own presentation framework with Compose! But wanting to be like all the cool presenters, I needed something like Keynote’s Magic Move for all my code examples! Compose has SharedTransitionLayout, how hard could this be? So I built my own version of Magic Move. And rebuilt it. And rebuilt it again. And Again. (And probably again between submitting and actually giving this talk) Let’s look at all those different iterations, the improvements each brought, and why diffing algorithms are hard.

What if you could *see* exactly what led to a crash or non-fatal error? In this talk, we’ll dive into the mechanics of mobile session replay and its impact on how developers debug and optimize Android apps. You'll get a hands-on look at how replay helps you: - Understand exactly what production users experienced before an error or crash - Quickly diagnose issues without needing endless custom logs We’ll also give a quick overview of Sentry’s mobile monitoring platform and how Session Replay fits into a faster, smarter debugging workflow. With Session Replay, developers gain the context they need to not just fix issues — but truly understand and improve the mobile user experience.

Mobile application security, especially time spent on applying it, is often seen as a necessary evil. Security tools that are actually effective require additional configuration efforts, and that doesn't always line up with the skillset needed to build great mobile apps. To optimize apps for performance, another set of manual processes is required to configure the build tools. On top of that, even when developers manage to configure these tools, app security and performance improvements are not always guaranteed nor noticeable by the end users. What if the skillset required for using these protection tools would overlap with regular app development skills? What if using these tools would actually remove some of the manual work required to optimise your application and save you time? In this talk we will show how this is now a reality! Attendees will have the following take-aways: - A brief overview of advanced R8 optimisation features and the effort that goes into using them correctly. - Insight in the concept of profile based optimisations, its shared benefits for application protection and the amount of manual work it can prevent. - A demo show-casing how easy it can be to run through a profile based configuration step. - Practical and concrete examples of the non-security related benefits of a profile based configuration approach, e.g. automatic R8 baseline profiles, auto-generated keep-rules tailored to your code, order files to speed up native code loading, additional app size reductions beyond R8

Learn to build robust and engaging text experiences in Jetpack Compose. This session covers the state-based TextField API, Autofill integration, dynamic text resizing with AutoSize, custom input and output transformations, and more. Discover how you can use these powerful APIs to create seamless and delightful user interactions.

AI coding tools have had some of the most wild hype to ever emerge from Silicon Valley, which is no small feat. From the native mobile world, this has all seemed very distant, and easy to pass off as just hype. But, native mobile is mostly locked to specific IDEs, largely untouched by these tools until recently. There is a lot of hype, but there is a lot of reality, and it goes way beyond chat and verbose auto-complete. Native mobile is also unique, with separate apps doing basically the same things. That makes native mobile both largely overlooked, and uniquely positioned to benefit from these tools. Technical topics we'll cover: * The state of models today, and where they might go in the future * Agent tools * What you can do with AI beyond "it helps write tests" * The rapid rise of open-source tools directly competing with the commercial "household names" Moblie topics: * AI is amazing at "porting code". Making Swift from Kotlin and vice-versa * How that might impact native dev * How that might change the cross-platform vs native calculus * AI tools enable productive dev in unfamiliar languages and ecosystems (and how that should impact "platform silos") We've been integrating AI tools at all levels of work, and recently completed an iOS to Android port, mostly automated, in a fraction of the time the client estimated the project to take. Lots of hype, but lots of real utility. Far from replacing developers, developers can get the most out of them. As time goes on, they will be as essential as IDEs and source control. And it's all coming to the mobile ecosystem very soon.

In this talk we'll explore some of the experimental and upcoming language features in Kotlin. Kotlin is a fast-evolving language and there are a number of KEEPs that explain new features that the Kotlin community would like to added to the language. Many of these features are already available via experimental compiler flags. In this talk we'll explore some of these exciting new features so that you know what to expect in the next 1-3 years as Kotlin continues to evolve.

Traditional Android dialogs are hard to test, easy to leak, and painful to customize — and in a world of Compose-first apps, they’re overdue for an upgrade. At Block, we built a fully Compose-driven overlay system that eliminates dialog fragments, supports modern soft input behavior, enables screenshot testing, and has shipped to production in one of our core apps. In this talk, I’ll walk through how we built it, the lessons learned, and how your team can adopt or extend this system (including our plans to open source it). Whether you're working on popovers, full modals, or anchored dialogs — this talk is for you.

Gradle's scalability is critical to maintaining fast and efficient Android builds at scale, both in local development and continuous integration environments. In this roundtable discussion with experts from Gradle, we will explore recent and upcoming performance improvements, and how developers can stay ahead of the curve. Let's look at: >How do recent features like the Configuration Cache impact everyday build performance for Android developers? >What challenges and opportunities do upcoming efforts like Isolated Projects present for teams working at scale? >How can developers optimize their inner and outer development loops using existing Gradle capabilities? >What long-term strategies should teams adopt today to prepare for the next wave of Gradle performance enhancements?

Engineers and developers are tasked with deploying AI models, face a variety of unique challenges. One of the most important considerations is the creation of a reliable and repeatable feedback loop, allowing new data to be collected to improve model accuracy. This talk will cover some of the popular solutions and strategies to help establish an MLOps process and workflow for your unique use case.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. Scaling an app under rapid growth presents significant engineering and business challenges. Attendees will learn strategies for handling system scalability, maintaining reliability, and making critical engineering decisions under pressure. > What are the challenges of scaling systems rapidly? > What best practices exist for re-architecting apps under pressure? > How can engineering leaders balance business goals with engineering constraints? > What strategies exist for building resilient and scalable architectures?

Coroutines are an important tool in the Android developer’s toolbox. We use 'em to background our tasks, to parallelize our work, and to gracefully cancel operations. This is not a talk about that reasonable coroutines use. Instead, we’ll do unreasonable, forbidden things. We’ll study the implementation details of coroutines, scopes, and contexts. Once that foundation is established, we’ll start ‘thinking in coroutines’ and break our brains a bit! We’ll cover: 💣 Making I/O slower with `suspend` 💣 Turning code inside-out 💣 Using reflection with coroutines 💣 Treating the user as a function If you're willing to suspend disbelief, this talk is for you.

Compose Multiplatform, the declarative framework by JetBrains for building shared UIs, is now stable and production-ready on iOS – so it’s time to start building! In this talk, you will get an overview of the technology, and see what we’ve done to get to the stable release. This includes the evolution of our APIs, under-the-hood changes, and new tooling that we’re premiering for building Compose Multiplatform apps in your favorite development environments, IntelliJ IDEA and Android Studio. You’ll see that there’s a rich ecosystem available for you that has already grown to cover all major areas of app development. Putting it all together, you’ll see how Compose Multiplatform enables you to write production-grade apps on iOS and Android while reusing much of the knowledge you already have – and you’ll also get some insights into what we have planned next in the journey of Compose Multiplatform, on iOS and beyond.

In this talk, we will unveil our journey of optimizing Android WebView to reach performance levels comparable to native pages. We achieved this by refining resource loading, API requests, and page rendering processes. A key breakthrough in our efforts is a feature we dubbed "Native Worker." By harnessing Native Worker to parallelize the execution of JavaScript code, we significantly slashed WebView rendering times. These enhancements led to performance boosts of over 50% for more than 70% of the Web pages within TikTok, with some specific pages even experiencing performance gains exceeding 100%. Join us to explore how these cutting-edge optimizations can bring your WebView performance to the next level.

Get answers to all your pressing questions in Q&A sessions with Google's Android DevRel team.

To raise awareness about the increasing sophistication of mobile app attacks, particularly those leveraging AI, and to provide actionable insights into effective protection strategies. What to expect - Example of attacks that are been observed in the wild - Current Protection Approach Key Take Away - Considerations on how to combat new AI driven attacks

Building effective development teams hinges on prioritizing the developer experience. Poor tooling and inadequate support lead to cumbersome builds and inefficient workflows, creating friction that slows engineers and hinders their ability to deliver value. Join this peer discussion to share and discover practical strategies for boosting developer velocity and satisfaction. > How can we effectively measure the developer experience to pinpoint specific friction points that negatively impact team velocity and satisfaction? > What tools or strategies effectively boost knowledge transfer, reduce cognitive load, and accelerate onboarding? > What are your team's biggest DX pain points with builds, IDE, or CI, and what proven leadership tactics address them? > Where does your team experience the most friction day-to-day (e.g., with builds, IDEs, CI/CD, inefficient workflows)? What practical leadership tactics or tooling improvements have successfully addressed these pain points? > How can engineering leaders effectively quantify the impact of DX improvements on velocity, satisfaction, or overall value delivery to justify necessary investments to stakeholders?

Discover how the Model Context Protocol (MCP) connects AI to the real world. We'll explore the Model Context Protocol using the Kotlin SDK letting an Agent control Android devices with ADB! We’ll live code a new ADB tool and demo how AI Agents and the MCP can automate tedious device tasks, like setting up device permissions, streamlining your Android workflow. You’ll leave this talk understanding the Model Context Protocol, its Kotlin SDK, and be ready to build your own AI-driven integrations!

At Block, we have spent the past several months creating an LLM driven mobile testing framework, “Trailblaze”. It has enabled Square and Cash to run natural language based instrumented tests for Android both locally and in our continuous integration pipeline. This has allowed us to reduce manual effort for authoring and executing tests. This talk goes deep into the inner workings of Trailblaze as we share our lessons learned while building it. Learn the strategies we use to communicate effectively with the LLM and have it decide how to drive the user interface. Mobile AI driven tests are no longer science fiction, it’s here, works well, and will only get better. Come learn from our experiences and find inspiration to leverage AI to make your testing efforts more effective.

Exploring the basics of the new Jetpack Navigation 3 Compose library with the breakdown of the API and walking through all the new exciting features. Following the basics, we’ll take an in-depth exploration of how to architect navigation for scalability in large, evolving applications. We'll discuss effective patterns and practices, demonstrating how techniques like Dependency Injection facilitate integration and maintainability for production level applications.

Getting users to pay for your app is an art and a science. Let’s look at the current state of pricing strategies and different approaches to free trials. I’ll share some of the most recent market trends and share real-world lessons from successful apps. You’ll gain insights into current market trends and how user behavior is shaping monetization tactics. Whether you’re launching a new app or optimizing an existing one, this talk will provide actionable takeaways to help you price with confidence.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. As mobile teams scale, specialization becomes essential, but striking the right balance between deep expertise and cross-functional flexibility is challenging. This session will explore different specialization paths in mobile engineering and how leaders can structure teams, hiring, and career growth to maximize both innovation and long-term success. > What are the key specialization tracks in mobile engineering? > How can engineering leaders ensure specialization doesn’t create silos within a mobile org? > What strategies help balance hiring and training across specialized and generalist roles? > How does a specialist career track impact long-term growth, leadership opportunities, and adaptability? > What are best practices for integrating specialists into cross-functional product teams?

Dependency Injection remains a cornerstone of scalable Android architecture—but as the platform evolves, so do the tools and patterns we rely on. This panel brings together DI experts to discuss the current and future state of DI in Android, from Google’s Hilt and Kotlin-first Koin to community-driven frameworks like Dagger, Anvil, and Metro. We’ll explore real-world lessons and technical insights across topics such as: What are the key strengths and weaknesses of current DI frameworks, and how should teams choose the right tool for their architecture and scale? What are the tradeoffs of using DI at scale, and where do most frameworks begin to show their limitations? How can teams effectively manage complexity, performance, and maintainability as their DI setup grows? Can Dependency Injection be used for more than just wiring services and repositories? What are some unconventional or creative use cases, and how well do frameworks support them? What are effective strategies for migrating between DI frameworks, especially in large codebases? With Kotlin Multiplatform adoption increasing, how can DI be applied across shared and platform-specific code? What are the challenges of building and maintaining multiplatform DI solutions, and what opportunities does this unlock for cross-platform architecture? What goes into designing and building a DI framework from the ground up? What technical decisions, architectural patterns, and developer experience considerations must be addressed—and where do current solutions still fall short?

While Jetpack Compose simplifies UI development with its declarative paradigm, mastering its reactive nature, particularly optimizing recompositions and managing state hoisting, presents costly challenges for developers transitioning from imperative approaches. Subtle mistakes can lead to performance issues, and verifying efficient composition through testing remains challenging at scale. This session tackles these challenges head-on by diving into the world of Kotlin Compiler Plugins. We'll demonstrate how to build a custom plugin that hooks directly into the compilation process. Learn how to analyze Kotlin's Intermediate Representation (IR) to identify Composable functions and automatically inject instrumentation and recomposition tracking code before your app even runs. We will construct a practical compiler plugin designed to: >Track and visualize recomposition frequency using a heatmap, instantly highlighting performance hotspots. >Enhance unit tests by enabling assertions on specific recomposition counts, ensuring stability and efficiency. Attendees will leave understanding: >The core concepts and power of Kotlin compiler plugins. >Setting up a plugin project and integrating it via Gradle. >Analyzing Kotlin IR to target specific code structures like Composables. Join this session to unlock a powerful technique for building custom developer tooling, improving your Compose development experience, and shipping higher-quality, performant UIs to your users.

Join us as we discuss how enterprise mobile teams can achieve world-class Android app quality using an AI-powered mobile observability platform. Designed specifically for mobile environments, this platform proactively identifies performance and stability issues, enabling teams to resolve problems before they affect end-users. You'll gain insights into how advanced AI-driven observability enhances app performance, boosts user engagement, and delivers measurable business value.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. In this discussion, we'll review the state of Jetpack Compose adoption in 2025. At this point, an overwhelming number of companies are using Jetpack Compose, but many still have legacy view system screens to manage. Given that we still have work to do, let's get together and discuss: > What's the current level of Compose adoption on your projects? > What plans, if any, do you have to migrate legacy screens to Compose? > How are you managing View/Compose interop during this process? > What complications are presenting additional migrations to Compose? > Is a 100% migration to Compose a bad idea? (spicy takes!)

The Firebase AI SDKs provide access to the Gemini Pro and Flash models for text generation and Imagen for image generation. Integrating these models into your app can enable you to easily implement compelling intelligent functionalities that were previously difficult to achieve for Android developers. We also launched the new Gemini Live API enabling low-latency bidirectional streaming to support voice interactions with Gemini. We will also cover the latest on the Gemini Nano API for on-device inference. In this talk we will cover these capabilities in detail and review how you can integrate them into your production Android app.