Posted by Alice Yuan, Developer Relations Engineer at Google, Arti Arutiunov, Product Manager at Datadog and Nikita Ogorodnikov, Staff Software Engineer at Datadog Performance regressions are notoriously hard to reproduce, making regressions a massive bottleneck for mobile developers. Although signals like ANR rates indicate what issues occur in production, pinpointing the specific line of code that resulted in the performance issue has historically necessitated exhaustive manual reproduction or speculative trial-and-error experimentation. Datadog collaborated with Google to mitigate this frustration by integrating the ProfilingManager API (available on Android 15+ devices) into its Real User Monitoring (RUM) and Continuous Profiling platforms. This integration transforms the debugging workflow, allowing developers to move beyond surface-level symptoms to being able to detect the why behind a performance bottleneck. By leveraging this system-level API, Datadog now processes millions of production profiles weekly across the globe according to Datadog internal data of June 2026. It provides engineering teams with a new level of visibility into real-world performance, all while maintaining a low runtime overhead for production-scale performance monitoring. The impact of ProfilingManager ProfilingManager is a system service introduced in Android 15 that enables apps to programmatically collect performance data such as call stack samples, field traces and memory heap dumps directly from production environments. This capability shifts the engineering paradigm from reactive manual reproduction to proactive field analysis. For example, a
Google
communications app used field traces to investigate why its cold start times were slower on newer, more powerful hardware. By diving into the field-collected traces and comparing traces across different device types, the engineer discovered a hidden scheduling issue: a background text-to-speech service was unnecessarily being prewarmed during app startup. The traces revealed that this background process was monopolizing the device's highest-performing big CPU core, forcing the app's main thread to sleep while the prewarm occurred. Solving the Android code-level visibility challenge Prior to the implementation of ProfilingManager, Datadog’s Real User Monitoring (RUM) focused on high-level application health and session-level telemetry to assess the user journey. Engineering teams could monitor Android performance signals like time to initial display, ANR rates, CPU load, and frozen frames. These insights extended to granular interactions, such as network latency, touch events, and main thread hangs. However, while this data effectively highlighted which performance bottlenecks were surfacing in the field, it provided no clear path to identifying the root cause of these failures. To address this, Datadog needed a profiling engine capable of capturing Android traces directly from devices in production with minimal performance impact. After evaluating alternative approaches, such as writing their own trace processor using Android Debug APIs, the team selected ProfilingManager because it is the most performant solution of the profiling options they evaluated and offloads the sampling decisions overhead to the OS. ProfilingManager supports a wide range of collection methods, including CPU traces, call stack sampling, memory analysis through Java heap dumps and native heap profiles. It enables
developers
to profile production builds, upload trace files to external storage, and review them in the Perfetto trace analyzer UI. As a SaaS provider, Datadog uploads, visualizes, and analyzes these profiles collected via its SDK, providing a unified view of application health. By centralizing high-fidelity telemetry within a unified observability API, ProfilingManager empowers Datadog and its clients to proactively monitor, investigate, and remediate complex Android performance regressions through key technical advantages: Granular session diagnostics: ProfilingManager enhances debuggability by delivering direct OS-level trace data, overcoming the visibility and alignment challenges typical of custom logging with system services. To dive deeper,
developers
can download these traces from Datadog to investigate further in visualization tools like the Perfetto UI . Automated telemetry triggers: By leveraging native system events to initiate trace recordings at key optimization points, Datadog reduces the need to build custom collection logic. While the initial rollout focuses on the APP_FULLY_DRAWN signal, there are already plans to expand this observability to include ANR , OOM , and COLD_START triggers. Proactive trace snapshots: By interfacing directly with the system-level Perfetto service (traced), ProfilingManager utilizes a proactive background recording model designed to capture unpredictable issues. This ensures that
developers
receive a precise visualization of the events leading up to a performance anomaly, offering a level of insight that exceeds what is possible through manual instrumentation. Bottleneck detection at scale: Datadog is able to synthesize telemetry from across Datadog’s global customer base to uncover regressions that only emerge under unique hardware configurations and variable network environments. System-enforced resource stability: The API leverages sampling trace collection to ensure performance and user experience impacts remain unnoticeable. On-device data controls: ProfilingManager filters out irrelevant information from other processes on-device before the profile is delivered to the app. This minimizes file sizes and ensures that only data relevant to the app's processes is provided. Processing millions of weekly profiles to optimize real-world apps An example of Datadog's time to initial display measurement with stack sampling powered by ProfilingManager Integrating a system-level profiling API into a global monitoring SDK required solving infrastructure challenges. Because ProfilingManager generates highly detailed performance traces, the Datadog engineering team had to build a pipeline capable of parsing and analyzing these profiles on the server side at scale. Beyond profile collection, Datadog also emphasizes the importance of balancing sampling frequency with collecting enough data to generate meaningful insights about your application. Datadog relies on ProfilingManager’s built-in rate limiting as a critical stability safeguard, preventing excessive telemetry requests from overburdening user devices. The team has been profiling Datadog's own native Android application and a number of early adopters’ applications for months, gathering millions of profiles to ensure a fast, error-free launch experience and to refine their performance-detection algorithms. Today, the production integration seamlessly scales across a variety of Android devices. Conclusion By integrating Android’s ProfilingManager API, Datadog successfully closed the visibility gap between backend systems and mobile client applications for their customers. By processing millions of profiles weekly with negligible device overhead, Datadog equips Android
developers
with the code-level insights necessary to diagnose complex performance bugs instantly, helping
developers
build smoother applications and improve their app’s performance signals in the Play Store. To adopt the ProfilingManager API directly into your performance observability framework, check out our documentation . In the future, Datadog aims to make Android profiling data a first-class input for coding agents to autonomously resolve performance bottlenecks, closing the feedback loop between detection and remediation. Datadog is working toward making Android profiling broadly accessible to
developers
. To get started using the Datadog real user monitoring feature powered by ProfilingManager, visit Datadog Mobile Real User Monitoring .
Posted by Alice Yuan, Developer Relations Engineer, Ajesh Pai, Developer Relations Engineer, and Fung Lam, Developer Relations Engineer While app performance is often equated with a smooth UI and fast start times, memory serves as the silent foundation upon which these visible metrics are built. It's no secret that we're seeing a shift where device memory is more important than ever. Not only have we made strides in Android memory optimizations with Android 17, we're providing the tooling and API support to help you stay ahead of stricter memory requirements later this year. To ensure device stability, starting in Android 17, the system will begin enforcing app memory limits based on the device's total RAM. If an app exceeds those limits, Android will kill the process with no associated stack trace. Beyond these forced terminations, unoptimized memory usage inevitably degrades the user experience. When the app approaches heap memory limits, it triggers frequent garbage collection—leading to noticeable UI stutters. Furthermore, when a device runs out of available memory, the system scrambles to reclaim pages, causing CPU strain, UI latency, and battery drain. If the memory shortage is too severe, it can cause Low Memory Killer (LMK) events that abruptly terminate background processes and force apps to have slow cold starts and lose user state. To build highly performant apps and avoid these forced terminations, we recommend that you adopt the following memory optimization strategies: Maximize bytecode optimization with R8 Optimize image loading Detect and fix memory leaks with Android Studio Trim memory when app leaves visible state Advanced memory observability with ProfilingManager A condensed version of this blog post is also available in video format, go check it out! Understanding Android 17 app memory limits App memory limits are being introduced in Android 17 to prevent "one bad actor" from destroying the multitasking experience and stability of the user’s entire device. Here is a breakdown of the reasons driving this architectural change: Preventing cascading kills: When an app becomes bloated or leaks memory while holding a privileged state (e.g. it’s running a Foreground Service), it is initially shielded from the system's Low Memory Killer (LMK). As this single app grows unchecked and hoards RAM, the LMK is forced to compensate by killing off dozens of smaller, well-behaved cached apps and background jobs to reclaim space for the memory hog. Preserving multitasking and user state: When the system is forced to purge cached apps to accommodate a single leaking process, the multitasking experience is severely degraded. Users returning to prior cached applications encounter sluggish cold starts instead of near-instant warm resumes. This inefficiency generates more CPU strain and accelerates battery depletion. It can also destroy the user’s context in recently used apps, such as scroll positions, navigation stacks, and in-game progress. To determine if your app session was impacted by these constraints in the field, you can call getDescription() within ApplicationExitInfo . If the system applied a limit, the exit reason is reported as REASON_OTHER and the description string will contain "MemoryLimiter:AnonSwap". You can also leverage trigger-based profiling using TRIGGER_TYPE_ANOMALY to automatically capture heap dumps when the memory limit is reached. Furthermore, Android is actively working to surface more in-field memory metrics to developers within the Google Play Console. We have also expanded our memory limits documentation to include local debugging commands, allowing you to simulate memory constraints in your local environment and validate your application's behavior under any memory limit enforcement. Maximize bytecode optimization with R8 A highly effective way to reduce your app's memory footprint is to enable the R8 optimizer. By shrinking classes, methods, and fields into shorter names and stripping out unused code and resources, R8 significantly reduces your app's memory footprint by minimizing the amount of resident code required during execution. R8 minimizes resident code, shrinking the memory footprint and lowering LMK termination risk. This results in more frequent warm starts over slow cold starts. Additionally, streamlined bytecode reduces main-thread CPU overhead, directly cutting ANR rates for a more fluid user experience. For example, the digital bank Monzo enabled full R8 optimization and saw a 35% reduction in their ANR rate, a 30% improvement in cold start rate, and a 9% reduction in overall app size. The digital bank Monzo enabled full R8 optimization and boosted performance metrics by up to 35%. To properly configure R8 in your build.gradle file: Set isShrinkResources = true and isMinifyEnabled = true . Use proguard-android-optimize.txt instead of the legacy proguard-android.txt , which actually prevents optimizations and is no longer supported in Android Gradle Plugin 9. Remove android.enableR8.fullMode = false from your gradle.properties . If you are using reflection in your code base, then add Keep rules to prevent R8 from optimizing those parts of the code. Make sure to scope the keep rules narrowly to get the maximum optimization. To get the maximum optimization, make sure to follow these best practices in your keep rule file. Remove global options like -dontoptimize , -dontshrink , and -dontobfuscate that prevent R8 from optimizing the entire codebase Remove keep rules that prevent optimizing Android components like Activity, Services, Views or Broadcast receivers. Refine the broad package wide keep rules to target only specific classes or methods. To see more best practices, view our keep rules documentation . Library Developer R8 Best Practices If you are a library developer, strictly place the rules your consumers need into your consumer-rules file, and keep your library's internal protection rules in your proguard-rules.pro file. For more information on how to optimize libraries, see Optimization for library authors . R8 Configuration Analyzer To audit your R8 optimization, use the Configuration Analyzer . Configuration analyzer shows the current state of optimization with Obfuscation, Optimization, and Shrinking scores. With configuration analyzer, you can also understand how many classes, methods or fields are prevented from optimization by each keep rule. Refine these broad package wide keep rules to unlock the maximum optimization. Using configuration analyzer, you can also identify keep rules that are subsuming other keep rules, redundant keep rules and unused keep rules. The Configuration Analyzer shows the current state of optimization with Obfuscation, Optimization, and Shrinking scores. R8 Agent Skill You can also leverage the R8 Agent Skill with Android Studio agent or other AI tools to resolve misconfigurations and refine your rules resulting in improved app performance. (Insights from AI-driven skills will require technical verification) Optimize image loading Bitmaps are usually the largest common objects residing in your app's memory. They represent the final stage of the image loading process where compressed files, like JPEGs or PNGs, are decoded into raw pixel data for display. This means a tiny 100KB compressed image can balloon into several megabytes of RAM because memory consumption is determined by the image's pixel dimensions and color depth. Since bitmap operations are frequently on the critical path to drawing frames, unoptimized images cause severe memory bloat and UI jank. Google recommends leveraging image loading libraries Coil for Kotlin-first projects, particularly when developing with Jetpack Compose and Glide for Java-based applications. Adopt these five best practices Downsample images: If you’re loading bitmaps manually, avoid loading a massive image into a tiny thumbnail view; use inSampleSize to load a smaller version. Glide and Coil downsamples images by default and you can configure this downsample strategy using DownsampleStrategy and ImageLoader respectively. Cropping: Avoid embedding padding directly into an image file for letterboxing purposes (e.g., creating a transparent border to expand an image dimensions). Rather than baking in these borders, utilize InsetDrawable or apply padding directly within the View or Composable containing the bitmap. Config: Balance memory and quality by choosing the right pixel format. Use RGB_565 when transparency isn't needed, which uses half the memory of the default ARGB_8888 format. In Glide you can configure this by using DecodeFormat and in Coil you can use bitmapConfig property. Prioritize vector drawables: For basic geometric assets, leverage ShapeDrawable as a lightweight alternative to decoding rasterized bitmaps. By defining these assets once via XML, you ensure they scale seamlessly across all display densities while effectively eliminating resource-driven memory bloat. Reuse: If your application manages Bitmaps manually then to minimize memory churn, when a bitmap is no longer required, the app should call bitmap.recycle() and immediately discard the Bitmap reference. If you use an image loading library like Glide or Coil, return the bitmap to the library’s managed pool. By providing an existing buffer for future memory needs, the pool effectively avoids the overhead of new allocations. Check out our documentation on Optimizing performance for images to learn more. Android Studio tooling You can also eliminate redundant bitmaps using Android Studio Narwhal 4. Here is how to hunt them down in five simple steps: Open the Profiler tab in Android Studio Click Heap Dump (or "Analyze Memory Usage") and hit record to take a snapshot of your app’s current memory state. Scan the analysis results for the yellow warning triangle ⚠️, which Android Studio uses to flag duplicate bitmaps being stored multiple times. Alternatively, navigate to the profiler header, choose "Filter by:" and pick the "Duplicate Bitmaps" setting. Click on any flagged entry to open the Bitmap Preview pane, allowing you to see exactly which image is the repeat offender. Use that visual confirmation to track down the redundant loading logic in your code and implement a better caching strategy. Look for the yellow warning triangle ⚠️ in heap dumps when using the Android Studio Profiler. Detect and fix memory leaks with Android Studio Memory leaks in Android occur when your code holds onto an object's reference long after its lifecycle has ended. This prevents the Garbage Collector (GC) from reclaiming that memory, eventually leading to sluggish performance or OutOfMemoryError (OOM). Android Studio Panda 3 features a dedicated LeakCanary profiler task, allowing developers to analyze real-time memory leaks and map traces within the IDE. The LeakCanary profiler task in Android Studio actively moves the memory leak analysis from your device to your development machine, resulting in a significant performance boost during the leak analysis phase as compared to on-device leak analysis. LeakCanary memory leak analysis contextualized with Go to declaration for debugging Additionally, the leak analysis is now contextualized within the IDE and fully integrated with your source code, providing features like go to declaration and other helpful code connections that drastically reduce the friction and time required to investigate and fix memory leaks. Examples of common memory leaks Memory leaks occur when an object persists in memory beyond its intended lifespan. This typically happens due to: Retaining references to Fragments, Activities, or Views that are no longer in use. Mismanaging Context references. Failing to properly unregister observers, listeners, and receivers. Creating static references to objects that are bound to components with shorter lifecycles. Here are a few example scenarios: Scenario Compose-based example View-based example Leaking Context Example: Passing LocalContext.current to a ViewModel Fix: Keep Context dependent logic within the UI layer. For non-UI layers, refactor to use dependency injection or observe UI state using Kotlin flow . Example: Storing an Activity in a companion object or static variable. Fix: Don’t hold static references to UI components. Refactor to use dependency injection or observe UI state using Kotlin flow . Leaking Listeners Example: Using DisposableEffect to start a listener but leaving onDispose empty. Fix: Perform the unregistration and cleanup logic inside the onDispose block. Example: Registering for SensorManager updates and forgetting to unregister. Fix: Manually call unregisterListener() in onStop() or onDestroy() lifecycle. Leaking Views Example: Holding a reference to a legacy View inside an AndroidView without a release strategy. Fix: Use the release block of the AndroidView composable to clean up the legacy View . Example: Keeping a reference to a view binding object after the Fragment is destroyed. Fix: Set the binding variable to null inside the onDestroyView () lifecycle method. Trim memory when app leaves visible state Android can reclaim memory from your app or stop your app entirely if necessary to free up memory for critical tasks, as explained in Overview of memory management . Android will usually reclaim memory from your app when it’s not visible to the user, such as by discarding some of your app’s code and data pages in memory or compressing your heap allocations. When the user resumes your app and your app tries to access some memory that’s been reclaimed, the OS will swap that memory back in on demand. This swapping behavior can be slow, and cause unexpected jank or stutters in your app. If you leave it to the OS to decide what memory to reclaim from your app, you may find that the OS reclaimed memory that you’ll need shortly after resuming your app. Instead, your app can voluntarily discard memory allocations that it can regenerate later, on demand and at a low cost. To do so, you can implement the ComponentCallbacks2 interface. You can implement onTrimMemory in your Activity , Fragment , Service , or even your custom Application class. Using it in the Application class is highly effective for global cache management. The provided onTrimMemory() callback method notifies your app of lifecycle or memory-related events that present a good opportunity for your app to voluntarily reduce its memory usage. In terms of memory lifecycle management, your implementation should focus exclusively on TRIM_MEMORY_UI_HIDDEN and TRIM_MEMORY_BACKGROUND . Since Android 14, the system has ceased delivering notifications for other legacy constants, which were formally deprecated in Android 15. TRIM_MEMORY_UI_HIDDEN : This signal indicates that your application's UI has transitioned out of the user's view. This provides an opportunity to release substantial memory allocations tied strictly to the interface—such as Bitmaps, video playback buffers, or complex animation resources. TRIM_MEMORY_BACKGROUND : At this level, your process is residing in the background and is now a candidate for termination to satisfy the system's global memory needs. To extend the duration your process remains in the cached state, and reduce the number of app cold starts, you should aggressively release any resources that can be easily reconstructed once the user resumes their session. import android.content.ComponentCallbacks2 // Other import statements. class MainActivity : AppCompatActivity(), ComponentCallbacks2 { /** * Release memory when the UI becomes hidden or when system resources become low. * @param level the memory-related event that is raised. */ override fun onTrimMemory(level: Int) { if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) { // Release memory related to UI elements, such as bitmap caches. } if (level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND) { // Release memory related to background processing, such as by // closing a database connection. } } } Note: The onTrimMemory integration may depend on SDK support. For instance, certain games rely on their game engine to enable this capability. Please check out the game memory optimization documents . Advanced memory observability with ProfilingManager To catch and diagnose memory issues in the field that cannot be reproduced locally, you should leverage the ProfilingManager API . Introduced in Android 15, this advanced observability API allows you to programmatically collect real-user Perfetto profiles. For teams that lack a dedicated infrastructure to manage and host performance artifacts, Crashlytics is exploring a specialized solution to streamline this workflow. They are inviting developers to provide feedback . Android 17 introduces new event-driven triggers , most notably TRIGGER_TYPE_OOM and TRIGGER_TYPE_ANOMALY : The OOM trigger automatically collects a Java heap dump at the exact moment an OutOfMemoryError crash occurs, providing precise allocation states. A collected OOM profile is provided the next time the app starts and registers the registerForAllProfilingResults callback. The Anomaly trigger detects severe performance issues, such as excessive binder spam or breached memory thresholds. The memory anomaly delivers a heap dump just prior to the system terminating the app. val profilingManager = applicationContext.getSystemService(ProfilingManager::class.java) val triggers = ArrayList () triggers.add(ProfilingTrigger.Builder( ProfilingTrigger.TRIGGER_TYPE_ANOMALY)) val mainExecutor: Executor = Executors.newSingleThreadExecutor() val resultCallback = Consumer { profilingResult -> if (profilingResult.errorCode != ProfilingResult.ERROR_NONE) { // upload profile result to server for further analysis setupProfileUploadWorker(profilingResult.resultFilePath) } profilingManager.registerForAllProfilingResults(mainExecutor, resultCallback) profilingManager.addProfilingTriggers(triggers) Once you’ve collected the heap dump, you can download the profile from the server, or locally via adb pull and drag and drop the file into the Perfetto UI . To streamline your memory debugging workflow, use the Heap Dump Explorer , this is the new default view for heap dumps in Perfetto UI. This tool provides an intuitive interface for inspecting Java heap dumps, allowing you to visualize object allocation hierarchies, compute retained memory sizes, and identify the shortest path from garbage collection root. By leveraging the Heap Dump Explorer, you can rapidly pinpoint memory leaks, bloated retained objects such as excessive bitmap allocations, and analyze heap object allocations all in one place. Use the Heap Dump Explorer ’s embedded flamegraph to visually inspect and navigate through objects with the highest heap allocations. Conclusion Optimizing bytecode with R8, adopting image loading best practices, and resolving memory leaks are critical steps toward delivering a high-quality user experience while managing resources effectively under pressure. Adopting these proactive measures helps maintain app stability and performance, preventing unexpected terminations while safeguarding user context. To further your performance expertise, explore our revised memory guidance .
Posted by Ataul Munim, Android Developer Relations Engineer A truly differentiated Android experience is about delivering premium delight wherever your users are. At Google I/O ‘26, we showcased how the latest advancements in the Android ecosystem can help you elevate your app's quality while maximizing development efficiency. To help you build apps that stand out, we're diving into the key tools and libraries designed to optimize your core performance, extend the surfaces of your app to other devices, and streamline how your app handles high-quality media. Here is a recap of the essential updates and sessions you need to know to deliver a next-level experience across form factors! Maximize app performance and ROI with the R8 Configuration Analyzer A premium experience is only as good as its foundation, and a performant foundation is what allows your app to scale across the Android ecosystem. This is especially true with the release of Android 17, which introduces conservative, device RAM-based app memory limits to target extreme memory leaks and outliers before they cause system-wide instability. To stay below these new system thresholds and prevent your app from being terminated, having a lean footprint is no longer optional: it’s a critical requirement. This year, we’re making it easier to build highly optimized, fast apps by introducing the R8 Configuration Analyzer in Android Studio. R8 is your most powerful tool for improving app performance, but its effectiveness is often limited by overly broad "keep rules" that prevent the compiler from stripping away unused code. The new Configuration Analyzer provides optimization, obfuscation, and shrinking scores, allowing you to identify specific rules that are preventing the benefits of R8 optimization. By optimizing their R8 configurations, developers at Monzo achieved a 30% improvement in cold starts and a 35% reduction in ANRs. Smaller, faster code isn't just about efficiency; it's about ensuring your app has the memory headroom to deliver delight on every form factor, from the phone to the car. Extend your reach with a unified approach to Widgets on Phones, Watches and Cars User interaction is shifting toward quick, glanceable moments—short bursts of information that keep users connected without needing to open the full app. To help you increase the reach of your app content, we are unifying the development experience across the Android ecosystem with Jetpack Glance. By using a consistent, Compose-based model, you can elevate the content most important to your users straight to the phone’s home screen, Wear Widgets (previously Tiles!), and cars with a familiar workflow. In order to help users engage with your content and features, even outside your app, we are making widgets more expressive and adaptive with RemoteCompose. On Wear OS, RemoteCompose allows you to use the Compose tools you’re already comfortable with to define UI logic that renders natively on remote surfaces, ensuring that your glanceable experiences remain highly performant and responsive even on resource-constrained hardware. On mobile and cars, RemoteCompose is used as a new framework giving Widgets new expressive capabilities. You can use Jetpack Glance (together with RemoteCompose on Wear) to deliver a cohesive user journey. Whether it’s viewing flight status on the car dashboard, checking a gate change on a watch, or managing a boarding pass from a phone widget, this shared approach maximizes your app’s presence while keeping your development effort focused and efficient. Supercharge your media pipeline with a complete, production-ready toolkit Android has become a world-class home for the entire media lifecycle, and we are simplifying the journey from the first capture to the final playback. By leveraging Jetpack CameraX and Media3, you can build professional-grade experiences that feel native across the entire ecosystem. It starts with high-fidelity capture using the CameraXViewfinder Composable, which ensures your preview remains perfectly scaled and responsive on any form factor, including foldables and tablets. Use this to build adaptive capture experiences like a picture-in-picture view for multi-tasking, or that take advantage of modern features like high-frame-rate or slow-motion capture with CameraX v1.5. The new Media3 AI Effects library will provide a unified interface for premium features like Image & Video Enhance, Magic Eraser, and Studio Sound. This allows you to focus on the creative intent while Media3 handles the heavy lifting of choosing the most efficient and reliable path for the device. Then, use the latest improvements in multi-asset editing with Media3 Transformer to composite your edited videos together! Complete the pipeline with tools designed for professional-grade export and viewing, including: CodecDB, which offers data-driven encoding recommendations tailored to specific chipsets, ensuring your exported videos maintain high visual quality with minimal noise or blurriness Scrubbing Mode in ExoPlayer to provide the buttery-smooth seeking experience users expect from premium media apps Enhanced Cast support with the new CastPlayer API in Media3 By unifying these technical pillars, you can build a cohesive, high-performance media journey that delivers both delight for your users and high ROI for your development team. For more details, check out the premium Android experience YouTube playlist .
Posted by Jingyu Shi, Staff Developer Relations Engineer At Google I/O 2026, we introduced Android’s shift from an operating system to an intelligence system. We also demonstrated how you can build intelligent experiences natively with the system and bring the power of Google’s AI into your apps. If you missed these updates, check out our quick recap video here: 1. Putting your apps at the center of the intelligence system The Android OS already enables agents like Gemini to complete task automation, where it can navigate an app on the users behalf. AppFunctions (Android MCP) provides you with more control over how your app integrates with the intelligence system. This new platform API and Jetpack library are currently available in experimental preview. Android MCP: AppFunctions allows your application to act as an on-device Model Context Protocol (MCP) server. It means you seamlessly share your app's tools, services and data to the system and agents. Streamlined Development: You can leverage the new skill to easily generate AppFunctions within your codebase. Exploration and Testing: We’ve released a new test agent that allows you to experiment and debug your AppFunctions in a simulated agent environment. Early Access Program : Want to be among the first apps to deploy app functions in production? Join our early access program today! To see it in action, check out the live demo showcased during the What’s New in Android presentation. 2. On-Device Power with Gemini Nano 4 Preview Last month, we launched Gemma 4 , our state-of-the-art open models. You can already preview and prototype with the next generation of Gemini Nano (Nano 4) models with the AIcore developer preview . To make productionizing with Gemini Nano more reliable and performant, we are adding a few new features in ML Kit GenAI APIs : Prototype to Production: Transition from prototyping in the AICore Developer Preview to building production-ready apps using the ML Kit GenAI Prompt API to leverage Gemini Nano 4 that’s launching in flagship devices later this year. Structured Output: The upcoming Structured Output API will allow you to define object classes to be returned as outputs from Prompt API, ensuring reliable outputs in productionizing your intelligent features. Prefix Caching : It optimizes your on-device inference performance with the prompt API. The new Prefix caching reduces inference time by storing and reusing the intermediate LLM state of processing a shared and recurring part of the prompt. For highly customized or niche use cases, you can also use LiteRT-LM to bring your own fine-tuned small language model to Android. 3. Hybrid Inference & Agents To help you build more advanced AI features like hybrid inference and explore building in-app agents, we’ve released new APIs, framework and guidances: Firebase AI Logic Hybrid Inference : This new API provides the simple routing capability between on-device models and powerful cloud infrastructure. You can set explicit orchestration modes, such as PREFER_ON_DEVICE , PREFER_CLOUD , ONLY_ON_DEVICE , or ONLY_CLOUD , based on your need. A2UI Jetpack Compose Renderer: The new A2UI library allows your agents to "speak UI". With the upcoming Jetpack Compose Renderer, you can automatically render these A2UI messages as native UI components. ADK for Android : The first version of ADK for Android is available for experimentation. It allows you to build multi-agent workflows across both on-device and Cloud models while managing orchestration, context handling and sessions between agents. From building with on-device models, exploring hybrid inference to building agents, you can see them in action in this talk: Start Building Today Whether you are experimenting with AppFunctions to prepare for the intelligence system, or looking to bring the power of Google’s AI within your own app, we’ve got you covered. Dive deeper into the code snippets, samples and comprehensive developer guides on the Android AI hub . For the full breakdown of what’s new, check out the official AI on Android at Google I/O 2026 playlist . We are excited to see what you build!
Posted by Matthew McCullough, VP, Product Management, Android Developer Today at Google I/O, we announced the many ways we’re powering agentic workflows to increase your productivity and ensure your apps shine across the expanding Android ecosystem. Here’s a recap of 17 of our favorite announcements for Android developers; you can also see what was announced last week in The Android Show: I/O Edition . Stay tuned over the next two days as we dive into all of the topics in more detail! Build High Quality Android Apps Using Agents 1: Android CLI: helping you build with any agent, LLM, and tool Android CLI is now stable . It offers programmatic tools that allow any AI agent, including Claude Code, Codex, or Antigravity, to perform core Android tasks much more easily and efficiently. With today’s release, it also provides a bridge to tap directly into the "heavy-lifting" power of Android Studio to give you the production-ready polish needed for professional Android development. By leveraging the new android studio commands, developers can now grant their preferred agents the ability to perform semantic symbol resolution, analyze files for warnings, and even render Jetpack Compose previews. This release also enables official support for "Journeys" through new Android skills , which enables agents to execute end-to-end UI tests under your direction. Watch the developer keynote , and tune into the What’s New in Android tools talk for more information. You can now easily install Android CLI for use with Google Antigravity 2.0. 2: Build production-ready apps with ease in Google AI Studio Developers and creators can now build native Android apps, simply with a prompt in Google AI Studio . The apps are built with development best practices like Jetpack Compose, Kotlin, and APIs that leverage our recommended developer patterns. Google AI Studio enables developers to prototype, iterate via an embedded emulator, and deploy to physical devices without heavy local installations. Developers are then able to take those apps and share them to Android devices, as well as share them with others for testing through Google Play Console’s internal testing track. If a developer wants to prepare their app for a wider release, they’re able to take it to Android Studio for advanced debugging, testing, and UI polish. Watch the developer keynote , and tune into the What’s New in Android tools talk for more information. Use the embedded Android Emulator to create Android apps in Google AI Studio 3: Accelerating AI coding assistance with Android Bench Android Bench is our LLM leaderboard for Android development challenges. The goal is to accelerate model improvements, so you have more useful options for AI assistance. Many of you have been using open-weight models for AI assistance, so we’re now adding commonly used ones, such as Gemma 4, to the leaderboard, so you can see how LLMs that offer offline access and additional flexibility for power-users measure up. We're continuously working on increasing the difficulty of challenges we’re giving LLMs, to continue encouraging more useful improvements. 4: Convert iOS apps to Android with the Migration Assistant in Android Studio The Migration Assistant in Android Studio is designed to port apps from platforms like iOS, React Native, or web frameworks to native Android. By simply selecting an existing project, developers can have the agent intelligently map features, convert assets like storyboards and SVGs, and implement Android best practices using Jetpack Compose and our recommended Jetpack libraries. This effectively transforms what used to be weeks of manual porting into a streamlined agentic workflow that only takes hours. We shared a preview of the incoming feature in the developer keynote . A sneak peek of the Migration Assistant converting an iOS app into a native Android app Building AI Into Your Apps 5: Building Intelligent Apps with generative AI Generative AI enables you to create apps that are more intelligent, personalized, and agentic than ever before. This year, we introduced the latest advancements in on-device intelligence with a preview of Gemini Nano 4 for tasks like data extraction and summarization. We also expanded cloud capabilities via Firebase AI Logic, allowing developers to leverage Gemini models with robust grounding (including URL, Maps, and web search) to build smarter, more capable assistants. Furthermore, we unveiled our hybrid inference approach and the new Agent Development Kit (ADK) for Android , alongside communication protocols like AG-UI and A2UI that simplify the creation of autonomous, agentic experiences. To start integrating these powerful features, explore the developer documentation , and watch the technical deep dive session where we showcase all these technologies. 6: Experiment with AppFunctions today AppFunctions is an Android platform API with an accompanying Jetpack library to simplify building Android MCP integrations. It empowers your apps to behave like on device MCP servers, contributing functions that act as tools for use by agents and assistants. AppFunctions integration with Gemini is currently in a private preview with trusted testers, and you can begin preparing your apps already. You can sign up for the Early Access Program and start experimenting using the API guidance , sample , and skill today. The Future is Adaptive 7: Android is now Compose First; Views are now in maintenance mode. Compose is our standard for UI development, and we are moving to a Compose-first approach for all future guidance and libraries. Building on five years of evolution, the latest releases deliver a more mature toolkit, from the highly customizable Styles API to refined shared element transitions and enhanced input support. These updates allow you to build beautiful, adaptive apps with less code and better performance. Learn more about what Compose-first means for Android Development in our blog post . Build Android UI with Compose 8: Building seamless Android experiences across devices with Jetpack Compose The Android ecosystem is now Adaptive by Default , moving fluidly across phones, foldables, tablets, cars, XR, and expanding usages with Googlebook and connected displays. With over 580 million large-screen devices, and users on multiple devices spending up to 14x more on apps, the investment in adaptive design presents a massive opportunity. Jetpack Compose is the definitive engine for this transition, offering core tools like our latest Jetpack Navigation 3 release, new experimental Grid and FlexBox layouts, enhanced non-touch input support, and CameraX for correct camera previews across any window size. Furthermore, new skills in Android Studio make updating your existing app to adopt these adaptive patterns easier than ever. Notability’s Android debut sets a new standard for premium productivity apps. Built with Jetpack Compose, Navigation 3, and Kotlin Multiplatform, it delivers an intuitive, adaptive experience across devices. 9: Create seamless experiences for Googlebook Last week we announced Googlebook , a high-performance laptop that provides a large-screen canvas for your existing apps. Building with adaptive principles today helps ensure your app will work on Googlebook. Get started by reviewing relevant design guidance and developer guidelines for desktop experiences. Try out the new Desktop Emulator available in the Android Studio Canary to to test your apps for this form factor today. New Desktop Android Emulator 10: Unified widget development experience with Jetpack Glance Android 17 marks a shift toward a single, Compose-based development model for all widgets. By unifying the experience across mobile, Wear OS, and cars through Jetpack Glance, you can soon scale UI components across the ecosystem with a familiar workflow. The breakthrough this year is the integration of RemoteCompose. On mobile and cars, it powers high-fidelity animations, while on Wear OS, it allows Wear Widgets (formerly Tiles) to render complex UI logic natively on remote surfaces. This ensures peak performance on low-power hardware while allowing a cohesive user journey—like checking a flight status on your car dashboard and seeing gate change updates on your wrist. Four widgets are shown cycling through in the Android Auto interface. A clock, a contact card, Google Home favorites and a photo. 11: Expand your reach on the road with Android for Cars To help you expand your reach when you build in-car experiences, we're making it easier to build once and deliver your apps to Android Auto and Android Automotive OS. With the latest releases of the Car App Library, you can build customized, distraction-optimized templated media apps for both platforms. We're introducing new components and template capabilities to give you increased flexibility and more options for laying out content. Parked experiences are expanding too, with immersive video playback coming to Android Auto for phones running Android 17. You can easily adapt your video apps for these parked experiences; apply now to the early access program to publish in these beta categories and learn more about the latest updates in our blog . 12: Accelerate your development with Android XR Developer Preview 4 Inspired by the innovative experiences you’ve built for the platform, we’re continuing to mature our tools with Developer Preview 4 of the Android XR SDK . A key milestone in this journey is the transition of our core libraries, XR Runtime, Jetpack SceneCore, and ARCore for Jetpack XR, moving to Beta soon to provide a more stable and performant foundation. We are also accelerating hardware access through the Android XR Developer Catalyst Program , where you can apply for XREAL’s Project Aura, audio glasses, or display glasses developer kits. Watch The latest in Android XR session or read our blog to see how these updates help you build experiences across the ecosystem. Early preview of the Geospatial API in ARCore for Jetpack XR, enabling high-precision anchoring of digital content to real-world locations. 13: Android is your new home for professional-grade media experiences Android 17 streamlines the entire media lifecycle with a production-ready toolkit. High-fidelity capture is now simplified with the CameraXViewfinder Composable, which handles complex scaling and responsiveness on foldables and tablets. For post-production, the new Media3 AI Effects library provides a single interface for premium features like Magic Eraser and Studio Sound, automatically optimizing for the device's hardware. The pipeline is completed by CodecDB, offering chipset-specific encoding recommendations to eliminate export noise, and a new Scrubbing Mode in ExoPlayer for ultra-smooth seeking. Whether you’re compositing multi-asset edits with Media3 Transformer or using the streamlined CastPlayer API, these updates ensure a professional-grade experience with significantly less development overhead. Low Light Boost and Magic Eraser in action 14: Increase app discovery and engagement on Google TV Pointer remotes, which enable motion-controlled input, will be a future way for users to interact with Google TV as it unlocks faster user navigation. App developers can start declaring support for pointing input to ensure their apps are discoverable on future TVs with pointer remotes. Additionally, the Engage SDK, formerly known as the Video Discovery API, optimizes Resumption, Entitlements, and Recommendations across all Google TV form factors to boost app discovery and engagement. It’s a great time to start onboarding the Engage SDK now, since the legacy Watch Next API, which has been powering your continue watching 1.0 experience, will lose support in the 2nd half of 2027. Get all the details in our blog . 15: Performance: the foundation of a great app experience To help developers navigate memory limits in Android 17, we've launched a suite of optimization tools. The R8 Configuration Analyzer identifies keep rules that are bloating your binary, while ProfilingManager and the integrated LeakCanary in Android Studio streamline memory leak detection. Furthermore, the new Android Performance Analyzer offers advanced AI integration for complex trace analysis and automated SQL query generation to pinpoint performance bottlenecks. And The Latest on Driving Business Growth 16: What’s new in Google Play Today's updates from Google Play help expand your reach and scale your business with less complexity. We’re redefining Play Store discovery with an immersive, short-form video format called Play Shorts, while expanding your audience beyond the store with app discovery in the Gemini app on Android and web. Plus, we’re introducing powerful new capabilities like agentic catalog management for seamless bulk price and SKU updates, and using Gemini models to enable Play Console to pre-populate store listings from imported documents—making global localization effortless. Gemini will provide users with app suggestions during a search 17: And of course, Android 17 Android 17 includes new performance & system architecture improvements (in addition to app memory limits) like a lock-free MessageQueue and a GC with more frequent, less intensive young-generation collections to ensure system-wide stability and smoother UIs. The new contact picker and eyedropper API help minimize the use of sensitive permissions and unnecessary access to user data. Review the behavior changes to make sure your app is ready for Android 17, including background audio hardening and SMS OTP protection . Get ready to target Android 17 (API 37) with changes such as mandatory large-screen resizability, certificate transparency by default, and restricted local network access. You can start testing today by enrolling your device in the Beta or using the latest 17.0 emulator images. One more thing. the third beta of our Android 17 quarterly platform release (QPR1) just came out, and it contains a minor SDK release to support a few features that just couldn't wait for QPR2. Check out all of the Android & Play Content at Google I/O This was just a preview of some of the updates for Android developers at Google I/O. Tune into What’s New in Android for the latest news and announcements and follow Google I/O for much more over the following week!
Posted by Emma-Louise Leavey, Group Product Manager and Mike Taylor-Cai, Product Manager Starting today Google AI Studio can build entire Android apps for you in minutes from just a prompt. You don't need to install any software or configure any libraries, which significantly lowers the barrier to development. Whether you’re a seasoned developer looking to prototype at lightning speed or a creator building your first-ever mobile experience, you can now go from a single prompt to a high-quality, Kotlin-based Android app in AI Studio. You can easily install the app on your device, share it with others for testing, or send it to Android Studio for any further development. The power of native Android While AI has made it easy to generate web-based apps, people want more on their mobile devices. They expect the beautiful and usable modern app design and capabilities that come with native Android user experiences, built with the Kotlin programming language using Jetpack Compose, the official and recommended toolkit for Android development. Native Android apps bring the reliability of offline support, continuous background services, and the deep integration of hardware sensors like GPS, Bluetooth, and NFC. We've brought the technology that enables you to quickly create new projects with Gemini in Android Studio directly into the web-based AI Studio. Now, you get the best of both worlds: the ease of a prompt-based interface paired with the power of the Android SDK, all in your browser, no installation required. A seamless, end-to-end workflow We have streamlined the entire development lifecycle so you can focus on your idea: 1. Create your app and iterate in the cloud: Use the embedded Android Emulator directly in your browser to preview and interact with your app as it’s being built. No heavy SDKs to download, no local setup required. Use the embedded Android Emulator to create and edit Android Apps right in the web browser 2. Install instantly: Connect your Android phone using a USB cable and install your app directly from AI Studio using the integrated Android Debug Bridge (adb). Install the app on your Android device 3. Streamlined Publish to Google Play: Using your Google Play developer account , you can now publish your app directly from AI Studio for testing. AI Studio will automatically create your app record, package the bundle, and upload it to an internal testing track in Google Play Developer Console. Your app is available for you to install within minutes, and you can automatically update your app on your device as you develop it further in AI Studio. Publish the app to an internal test track in Google Play Seamless app development handoff As you iterate on your app in AI Studio, you may find you need more advanced Android tools or support for a wider variety of Android device types. To move beyond the browser, you can seamlessly hand off your project to Android Studio by downloading a ZIP file or exporting it directly to GitHub. Download zip file of Android app project files When transitioning to a team environment or local development, you can leverage any IDE or agent you prefer. For a specialized experience, we recommend Gemini in Android Studio , which features models designed with Android in mind, or Antigravity, which integrates Android CLI commands into Google’s agentic development platform. This workflow makes building high-quality apps more accessible while giving you total flexibility in how you use AI to scale your project. Start building today To ensure a safe, high-quality ecosystem from day one, we have focused our initial release on specific capabilities including: Personal utilities and simple social apps: You can rapidly prototype single or multi-screen apps, such as habit trackers, study quizzes, or event itineraries. Hardware-enabled experiences: Because you are building native apps, you can leverage device features like the Camera, GPS/Location, Accelerometer and Bluetooth using the native Android APIs, letting you optimize hardware-level performance. AI-powered experiences: You can create apps that feature Gemini API integrations, seamlessly embedding powerful AI capabilities directly into your mobile experience. What’s Next? We are moving fast to expand what’s possible for creators in AI Studio. Here is a sneak peek at what is coming soon: Managing Google Play Test Tracks: Coming soon, we will be adding the ability to invite testers to try your app directly from AI Studio. Firebase integrations: Out-of-the-box support for Firestore, Firebase Auth, Firebase App Check and other tooling critical for Android developers is coming soon. Head over to Google AI Studio right now to start building. Here is some inspiration to get you started… Turn your Google Pixel Watch into an aviation assistant Prompt: Build a small airplane "6-pack" instrument app for Google Pixel Watch. The 6 instruments should include attitude indicator, airspeed indicator, altimeter, turn coordinator, vertical speed indicator, and heading indicator. Use the Google Pixel Watch's sensors to power the instruments and display them clearly. Display one instrument at a time on the display. Swiping to the left or right should cycle through the instruments. Interactive Harmonium app on Google Pixel Fold Prompt: Build a Harmonium app for Pixel Fold devices, which plays like the instrument based on the hinge angle and touch gestures. The app should simulate the bellows and reeds accurately. An Android app for guitarists to become better musicians by jamming to backing tracks Prompt: Build an Android guitar practice companion app that features a two-tab navigation system: 'Fretboard' and 'Library'. The 'Fretboard' primary screen must contain an interactive guitar neck UI that visually maps out user-selected root notes, musical scales, and chords. Above the fretboard, implement a WebView-based YouTube player configured to play embedded videos inline. Additionally, include an AI generation feature that uses Retrofit to call Gemini Lyria 3 to create custom, 30-second backing tracks based on the user's currently selected key and scale. The generated audio files and their metadata must be saved locally using a database and displayed as a list in the 'Library' tab, where users can delete or play them. Finally, implement a persistent, globally visible mini audio player at the bottom of the screen, complete with play/pause toggles, a progress slider for seeking, and timestamp text, allowing the user to seamlessly practice on the fretboard tab while listening to their tracks. We are looking forward to seeing what you build next! Explore this announcement and all Google I/O 2026 updates on io.google .
Posted by Paul Lammertsma, Developer Relations Engineer With over 300 million monthly active devices across Google TV and Android TV, it’s clear that the living room is a massive, distinct platform for apps to accelerate growth. Today, we’re excited to share Google TV features and developer tools designed to increase the discoverability of your content and prepare your app for future TV experiences. Drive discovery and engagement with Gemini Last year, we brought our AI voice assistant, Gemini , to our platform, so that people can easily find what to watch, learn something new on the big screen, and get everyday tasks done with just their voice. Since launch, we’ve made improvements to how Gemini provides tailored responses to questions. Gemini shares a mix of visuals, videos, and text to help users find what they need, when they need it. For our streaming partners, Gemini is a helpful discovery engine—pulling from your app's metadata to surface your relevant content to viewers. Declare support for pointing modality The TV experience that we once knew is changing. Gemini is changing the way we discover and stream content with voice, but how we use the remote is evolving, too. Pointer remotes bring motion-controlled input to the big screen, unlocking faster user navigation across the Google TV Home page and within content-heavy apps. To ensure your app is ready for this shift and provides a great experience for all users, now is the time to start thinking about pointing input. Here’s how to get started: 1. Adapt your TV app UI Library You’ll need support for hover states, scrollable containers, and cursor clicks to enable pointer remote interactions for your app on Google TV. While implementation varies by UI stack, Jetpack Compose streamlines this transition, as most core components handle these multi-modal interactions natively out of the box. Hover state: Every focusable element on your screen (buttons, movie posters, setting toggles) needs a clear visual feedback mechanism for a hover state. This is often subtler than a focus state but critical for feedback. Scrollable containers: Pointer remotes will also have a small circular touchpad for scrolling. Users can use this touchpad to scroll up or down, or left or right in your app. Your app will need to respond to touch events to scroll. Cursor clicks: Many TV apps today expect a simple D-pad OKAY button “click.” With a pointer remote, a user may “click” on an element that’s not the D-pad focus state, but is instead from a hovered state (similar to a mouse click). 2. Test pointing interactions with a mouse today To see how your app handles hover, scroll, and clicks, simply connect a bluetooth mouse or wired mouse to your Google TV. Keep in mind that a mouse has more precise control, since users are closer to the screen and typically rest the mouse in a stable position. Pointer remotes can often be less precise, since users are sometimes 10 feet away from the screen, making rough gestures with the remote from their couch. As a TV designer or developer, you can mitigate this lack of input precision by having larger hover targets for elements. 3. Declare TV app support for pointer remotes on Google Play Finally, tell Google Play that your TV app is designed to work with a pointer. This ensures that users with pointer remotes will be able to easily find, install, and interact with your app. Within your AndroidManifest.xml, declare the meta-data tag, android.software.leanback. supports_touch . This tag informs the platform that your TV app “spatially supports touch,” since pointer remotes simulate touch events from a distance. AndroidManifest.xml <manifest ...> <!-- Signal whether the app is adaptive or built just for TV --> <uses-feature android:name="android.software.leanback" android:required="true|false" /> <!-- Ensure the app can be installed on conventional TVs --> <uses-feature android:name="android.hardware.touchscreen" android:required="false" /> <!-- Signal whether the app supports pointer remotes --> <meta-data android:name="android.software.leanback.supports_touch" android:value="true|false"/> <application ...> ... </application> </manifest> Tips: The android. software . leanback feature declaration indicates that your app supports D-pad navigation and is intended for distribution only on TV devices via Google Play. The new software attribute of android.software.leanback. supports_touch declares that in addition to D-pad, you have ensured that your TV app works well for pointer/cursor experiences via mouse (of today) and pointer remotes (of future). If you haven't already, now is the time to adopt Jetpack Compose . Hover, scroll, and clicks are common input modalities that are supported on various form factors, and building your app with an adaptive UI framework enables code reusability and reduced maintenance. Onboard the Engage SDK The Engage SDK, formerly known as the Video Discovery API, optimizes Resumption, Entitlements, and Recommendations across all Google TV form factors to boost app discovery and engagement. Resumption: Partners can easily display a user's paused video within the 'Continue Watching' row from the Home page. Entitlements: The Engage SDK streamlines entitlement management, which matches app content to user eligibility. Users appreciate this because they can enjoy personalized recommendations without needing to manually update all their subscription details. This allows partners to connect with users across multiple discovery points on Google TV. Recommendations: The Engage SDK even highlights personalized recommendations based on content that users watched inside apps. It’s a great time to start onboarding the Engage SDK now, since the legacy Watch Next API, which has been powering your continue watching 1.0 experience, will lose support in the 2nd half of 2027. To get started, head to goo.gle/engage-tv to learn more. We're excited to see how our latest Gemini experience and developer tools will optimize your discovery and drive user engagement on our platform. Explore this announcement and all Google I/O 2026 updates on io.google .
Posted by Simona Milanovic and Ben Trengrove, Developer Relations Engineers As Android developers, you have many choices when it comes to the agents, tools, command-line interfaces (CLI), and LLMs you use for app development. Whether you use Gemini in Android Studio, Antigravity 2.0, Antigravity CLI, or third-party agents like Anthropic's Claude Code or OpenAI'sCodex, our mission remains the same: to ensure that high-quality Android development is possible everywhere. At Google I/O ‘26 , we shared the latest leaps forward in agentic development, and showcased some of the newest capabilities of Android CLI —now stable at version 1.0 and ready for all Android developers to use. From new skills to enabling agent access to powerful Android Studio capabilities, we’re giving your agents the right tools to build alongside you. If you’re already using Android CLI and want to jump into using all the new features, just run android update . Otherwise, read further to learn more about how we’re making the agents you choose be better at building for Android. Android development unlocked for Antigravity Google Antigravity now includes an optional bundle of Android resources—including the Android CLI and skills—that you can install. You can either install the bundle during onboarding after installation, or later from the Settings > Customizations > Build With Google Plugins menu. This provides Antigravity with all the powerful tools and knowledge of Android CLI, enabling it to perform the core tasks necessary for Android app development more easily and efficiently—from creating projects to deploying your app on a new Android virtual device. You can now easily install Android CLI for use with Google Antigravity 2.0. Unlocking Android Studio capabilities for any agent Android CLI provides a lightweight interface for AI Agents to perform tasks and retrieve knowledge about Android development. However, there's benefits to specialization — Android Studio contains over a decade of Android expertise, built to handle even the most complex Android projects. This includes Android Studio's powerful static analysis engine, refactoring tools, dependency management, UI design and rendering libraries, and more. AI Agents can now tap into Android Studio's tools to gain many of these same capabilities. Your agents can now use Android CLI to access powerful capabilities of Android Studio. The latest version of Android CLI introduces the new android studio command. This enables the agent of your choice to leverage the deep, contextual capabilities of Android Studio to better understand and perform actions on an open Android project. By running Android Studio alongside your preferred agent with Android CLI, your agent’s tasks can more efficiently navigate the codebase to produce more precise code changes. And, when you use Android CLI to create and iterate on your project, transitioning to Android Studio is much easier, so that you can use the purpose built tools—such as, performance profilers, Compose Previews, and Android Device Streaming—to get that production-grade polish. When you have a project open in the latest preview version of Android Studio Quail, you (or your agent) can run the following command to check whether Android CLI has a connection established with your open project: $ android studio check pid: 32942 version: Android Studio Projects: READY JetSet /Users/adarshf/AndroidStudioProjects/jetset-main From there, the agents can use the android studio command to access powerful IDE tools to interact with projects more efficiently. Key commands include: analyze-file: Analyzes a file for errors and warnings using the editor's built-in inspections. find-declaration: Finds the exact definition site of a symbol (class, method, variable, field, constant, or Android resource/color) across the project using semantic resolution. find-usages: Finds all references and declarations of a symbol (class, method, variable, or Android resource) across the entire project using semantic analysis. render-compose-preview: Renders a Jetpack Compose UI Preview and returns a path to the image and UI hierarchy if successful. version-lookup: Get the latest information about which versions for specified app dependencies are available in common repositories, such as the Google Maven repository. By providing a programmatic solution, dependency management is less tedious and much less prone to flakiness. open-file: Opens a file directly in Android Studio. This is useful if the agent wants to direct your attention to view Compose Previews, performance traces, or other specific files in the IDE. For example, agents can now run the following commands to render a Compose preview for a new layout for your Android app, and then open the previews in Android Studio for you to take advantage of seeing multiple Compose Previews side by side and make AI-assisted edits right from the IDE. $ android studio find-declaration HotelDetailScreen $ android studio analyze-file .../JetPacker/feature/detail/src/main/java/com/example/jetset/feature/detail/HotelDetailScreen.kt $ android studio open-file feature/detail/src/main/java/com/example/jetset/feature/detail/HotelDetailScreen.kt To learn more about how to use these commands, run android help . And, to make sure your agents understand how to work with this tool, make sure to update the Android CLI skill by running android init . More ways to get started To make integrating Android CLI into your environments as seamless as possible, we’re making it available in more ways. You can now download and install Android CLI using more package managers: apt-get, winget, and homebrew. For example, you can run the following to install Android CLI using winget: winget install -e --id Google.AndroidCLI We’ve also updated the installation to a user-local directory, by default. You can find the commands for all supported operating systems plus additional download options on the Android CLI page . Support for Journeys Journeys are natural language descriptions of core user experiences. We are also introducing support for Journeys . With Journeys tools and skills included with Android CLI, any agent of your choice can now create and run Journeys—which are natural language descriptions of user journeys for your app that are saved directly to your project. (sped up) An agent running a Journey it generated for an app. Agents can run these journeys using the Android CLI to navigate your app exactly like a user would. This unlocks entirely new ways to test, validate, or collect data across the critical experiences of your app, all driven by natural language and executed by your agent. Expanding Android skills To help models better understand and execute specific patterns that follow our best practices, we are continuing to expand our library of Android skills . We’re shipping new skills that make Android development everywhere more capable, efficient, and productive: Display Glasses and Jetpack Compose Glimmer for XR: Provides guidelines for developing projected applications for Android Display Glasses using the Jetpack Compose Glimmer UI toolkit. Migration to CameraX: Helps you migrate legacy Android camera implementations (Camera1 or raw Camera2 APIs) to CameraX. Perfetto SQL: Translates natural language data prompts into Perfetto SQL queries and executes them against a local trace file. Adaptive UI: Instructions to make or update an app's UI so that it adapts to different Android devices Testing setup: Creates a basic testing strategy. Styles: Helps with adoption of the new Jetpack Compose Style API for new components, and supports migration to Styles API. AppFunctions: Analyzes Android codebases to recommend and implement new AppFunctions, and refines KDoc documentation for Model Context Protocol optimization. You can add these new skills to your workflow directly from the command line. To help your agents understand and use Android CLI right away, you can initialize your environment and install the base android-cli skill by running: android init From there, you can browse and set up your agent workflow by searching for the exact capabilities your agent needs: android skills list Once you've found the right skill, install it to your environment by running: android skills add –skill=<skill-name> Get started today To download the stable 1.0 release of the Android CLI, explore the new tools, and browse the complete documentation, head over to d.android.com/tools/agents today! Also, make sure you update to the latest preview version of Android Studio to unlock the latest features that Android CLI offers. We can't wait to see what you build with Android CLI 1.0 and how these new features supercharge your daily workflows. Join our vibrant community on LinkedIn , Medium , YouTube , or X and share your feedback. Explore this announcement and all Google I/O 2026 updates on io.google.
Posted by Android XR Team The Android XR ecosystem is expanding, and we’re committed to supporting developers who will build its next great experiences. Today, we’re opening applications for the Android XR Developer Catalyst Program , a dedicated initiative to accelerate the development of Android XR apps ready to launch within the next year. This program is designed to provide the resources, hardware, and grants to help you build and scale innovative experiences across wired XR glasses , like XREAL’s Project Aura , and intelligent eyewear (audio and display glasses). We are especially interested in seeing innovative experiences across media, gaming, productivity, and health, but we welcome any unique use case that helps users expand what's possible. Why join the catalyst program? We want to help developers navigate common barriers to entry for XR development by providing: Development Kits: Get early access to hardware development kits for wired XR glasses (XREAL’s Project Aura) and / or intelligent eyewear (audio and display glasses). Technical support: Gain access to specialized technical resources and support forums specifically designed to help you prepare your app for Google Play. Grant Opportunities: Submit a request and you may be eligible to receive a non-recoupable grant to accelerate your development. Ready to start building? Applications are open to developers looking to publish apps for the Android XR ecosystem in the next 6-12 months. You can build with Kotlin and the Jetpack XR SDK , or with Unity , Unreal Engine or Godot . If you need a spark of inspiration, you can check out existing XR Experiments and Samples to see how you can use the SDK for everything from spatial music to navigation. Once you have your concept ready, be sure to submit your application by June 30th by 11:59PM PDT. We can’t wait to see what you build. Start Your Application Explore this announcement and all Google I/O 2026 updates on io.google .
Posted by Paul Feng, VP, Google Play Eng, Product, UX At Google Play, we’re passionate about helping people connect with the experiences they’ll love, while empowering developers like you to turn great ideas into lasting business success. At this year’s Google I/O, we talked about our evolving business model that offers more choice and new ways for your apps and content to be discovered on and off the store. We also unveiled advanced tools and insights that will help scale your business with less complexity. Watch the keynote video below, or keep reading for the biggest updates from this year’s event. Expanding your reach by meeting users where they are Your apps and the incredible worlds you build are no longer just a single destination, but connected experiences that reach users across surfaces and devices. To help you meet users where they are, Google Play continues to evolve into a content-forward destination that delivers immersive and personalized experiences on the store, across their devices, and directly within your apps and games. Beyond the store: Expanding discovery to new surfaces & devices We're unlocking new opportunities for your apps and content to be discovered across the wider Android ecosystem. Surfacing your apps and content in Gemini : As people increasingly start their journeys with virtual assistants, we want to ensure your apps and their content are an essential part of this. In the coming weeks, we're enabling app discovery in the Gemini app on Android and Web, connecting your apps and games to millions of Gemini users. Later this year, Gemini will also surface over 450,000 movies and TV shows, as well as where to stream live sports, and deep-link users directly into your app content. Gemini will provide users with app suggestions and direct access to entertainment content during a search. Delivering personalized content across the ecosystem : Engage SDK surfaces deliver your content to over 30 million monthly active users and drive millions of app opens every month—a massive 45% increase year-over-year. And we’re making it even more powerful by expanding support for new surfaces and devices. Store listing integration : Starting next month, existing users will see Engage SDK content directly on your store listings. New tablet surfaces : We’re broadening reach across Android tablet surfaces, including home screen Collections. Global scale : Every Engage SDK surface can now scale your content across over 80 Play markets. Boost re-engagement by integrating with Engage SDK today. If your app is already integrated, no further action is required to benefit from these updates. On the store: Enhancing content formats and conversational search We’re also optimizing the Play Store to help grow your audience with engaging content formats and a more intelligent search experience, to make it easier than ever for users to find and connect with your app. Capturing attention with Play Shorts : Our full-screen, portrait, short-form video feed gives users a glimpse of your app’s look, feel, and functionality. Play Shorts is rolling out to users in the US and select developers, and we look forward to expanding this to more markets and developers in the coming months. Play Shorts provides a glimpse into your app’s look, feel & functionality. Enabling deeper search journeys with Ask Play : Building on AI-powered Q&A, which already answers 95% of user queries, we’re introducing Ask Play. This AI-powered overlay turns discovery into a natural conversation, understanding the full context of a user's question and adapting to follow-ups to recommend the right app. Plus, with Ask Play highlights , users can get a high-level summary of complex searches directly on the search results page to help find the right apps or games more effortlessly. Ask Play understands the full context and helps users find the right apps or games. In your games: Deepening player engagement and community Once players launch your title, the real challenge is keeping them in the action. Play Games Sidekick provides an in-game overlay that gives players instant access to gaming information—like AI-generated Game Tips, rewards, and achievements — driving higher engagement while keeping players immersed. Sidekick has already debuted in over 100+ titles , and we’re building on this momentum with: New social features : Starting next month, players can see which friends are playing the same game and track their achievements Global expansion : Sidekick expands to all participating titles this summer. Head over to Play Console to enable Sidekick and begin testing the user experience so that you're ready for our global launch, while also meeting one of our core Level Up program guidelines. Scaling your business with less complexity We’re streamlining your day-to-day tasks while providing more comprehensive reporting to help you capture more growth opportunities. Streamline your Play Store operations with AI We’re using Gemini models to handle the heavy lifting of localizing your store content and managing your catalog. Localize with less effort : Eliminate manual copy-pasting by uploading a structured file (like a CSV or Google Sheet). Gemini models enable Play Console to pre-populate your listings across different languages for your review. You can also leverage AI-translated subscription benefits to quickly scale your localization efforts. Instantly pre-populate store listings with localized translations. Convert search trends into growth : We’ve simplified the path from insight to action. When you click a keyword recommendation on your Grow overview page, Gemini creates a new custom store listing automatically tailored to that keyword—ready to deploy with just one click. Simplify catalog management : We’re introducing agentic catalog management to help you manage your one-time products. Soon, you can leverage new in-console capabilities to execute bulk price changes, import SKUs, and configure metadata, saving hours of manual work. New agentic capabilities in Play Console will make managing your catalog seamless. For a detailed look at these features and more, watch this video . Behind-the-scenes features that optimize your revenue We’re building tools to maximize your revenue at every stage—with zero developer work required. When a user decides to buy, our platform helps ensure that the transaction completes at the point of conversion, renewal, and retention. Optimizing conversion with delayed charging : When a payment initially fails, our risk models evaluate the transaction. If it’s low-risk, we grant the user access to your paid content while we retry the charge in the background. This means your lowest-risk subscribers get the best experience and you are less likely to lose them due to a temporary glitch. Boosting renewals with extended recovery periods : To prevent involuntary churn, we’ve extended the default account recovery period from 30 to 60 days to give subscribers more time to fix failed payments, like expired credit cards. This shift has driven up to an 18% reduction in involuntary churn and a 9% reduction in total churn for top developers. Maximizing retention with flexible flows : A rigid experience makes retention nearly impossible. Coming soon, our new in-app subscription management API lets subscribers change plans or accept a downgrade offer the moment they hit “cancel.” Combined with replacement modes that automate prorated refunds, you’ll have a powerful toolkit to save at-risk subscribers. Flexible flows let subscribers change plans or accept downgrades to boost retention. More reporting and AI-powered insights We’re providing more data and more AI-powered insights to help you understand your performance and ROI on Play. Measure your full marketing impact : See your app’s total visibility on Play with our new reach metric. Gain better insight into store listing performance with indirect value not previously reported. Analyze downstream impact—like engagement, retention, and monetization—with our new traffic source breakdowns. Optimize the path to purchase and retention : We’ve added cart conversion rates to your core performance metrics to help you identify and fix friction in your checkout flow. New data on subscriber tenure and churn reasons allow you to better pinpoint why subscribers leave and which segments are most at risk. Get faster answers : Using Gemini models, we’re expanding chart descriptions from the Statistics page to the Reach & Devices and Store Performance pages to help you spot trends instantly. With new interactive Q&A and proactive monetization insights, you can ask why a metric shifted and instantly receive tailored recommendations to optimize your business. Get instant answers and recommendations for optimizing your business. Protecting your success In addition to making it easier and faster to publish safer apps , we’re also making it easier to secure your app’s revenue and reputation. Defend your business against fraud and abuse : The new Protected with Play dashboard helps you monitor and configure your integrity, distribution, and monetization defenses all in one place. We’re also reducing warm-up latency for Play Integrity API, so you can use these checks during speed-critical user journeys to block threats and risky devices faster. The Protected with Play dashboard provides centralized insights to help you safeguard your app. Get proactive protection for your store and revenue : We work behind the scenes to help stop malicious activity before it impacts your business. Last year, our automated anti-spam protections blocked 160 million spam ratings and reviews while our anti-fraud efforts automatically protected apps using Play Billing from 3.2 billion dollars in fraud and abuse. Growing your business on Google Play Our latest updates reinforce our commitment to deliver the highest return on your team’s investment, by expanding your reach beyond the store, simplifying your day-to-day operations, and helping you better safeguard your success. We’re excited to see you use these new capabilities to create even more impactful experiences. Thank you for being a part of the Google Play community. Learn more about these announcements and all other Google I/O 2026 updates on io.google starting May 21.
Posted by Robbie McLachlan, Developer Marketing The wait is over! We are incredibly excited to share the Google Play Apps Accelerator class of 2026. We’ve handpicked a group of high-potential studios from across the globe to embark on a 12-week journey designed to supercharge their success. Here’s what’s in store for the program’s first ever class: Curated learning: virtual masterclasses and workshops led by industry trailblazers. Guidance & mentorship: 1-to-1 sessions covering everything from technical scaling to leadership. Direct access: exclusive sessions with experts from Google and the world's top studios. Without further ado, join us in congratulating them! Google Play Apps Accelerator | Class of 2026 Americas Anytune AstroVeda BetterYou Changed Focus Forge Human Program Know Your Lemons kweliTV Language Innovation Matraquinha MR ROCCO MUU nutrition NKENNE Skarvo Starcrossed Wishfinity Asia Pacific Human Health Kitakuji Lazy Surfers Mellers Tech Reehee Company Europe, Middle East & Africa cabuu Class54 Education Digital Garden EverPixel Geolives HelloMind ifal Idea Accelerator Maposcope Ochy Picastro Pixelbite Record Scanner Talkao unorderly Xeropan International Congratulations again to all the founders selected, we can’t wait to see your apps grow on our platform. The Google Play Apps Accelerator is part of our mission to help businesses of all sizes grow on Google Play and reach their full potential. Discover more about Google Play’s programs, resources and tools.
