Posted by Sam Bright - VP & GM, Google Play + Developer Ecosystem

Hi everyone,

Thank you for making 2025 another amazing year for Google Play.

Together, we've built Play into something much more than a store-it's a dynamic ecosystem powered by your creativity. This year, our focus was ensuring Play continues to be the best destination for people to discover incredible content and enjoy rewarding gaming experiences.

We're incredibly proud of the progress we've made alongside you, and we're excited to celebrate those who pushed the boundaries of what's possible-like the winners of our Best of 2025 awards. Watch our recap video to see how we've made Play even more rewarding for your business, or read on for a more in-depth look back on the year.

Evolving Play to be more than a store

This year, we focused on evolving Play into a true destination for discovery where billions of people around the world can find and enjoy experiences that make life more productive and delightful.

Making Play the best destination for your games business

Just a few months ago, we shared our vision for a more unified experience that brings more fun to gaming. Today, players often jump between different platforms to discover, play, and get rewarded. Our goal is to connect these journeys to create the best experience for players and, consequently, grow your business. Our first steps include these key updates:

• A new Gamer Profile that tracks cross-game stats, streaks, and achievements, customizable with a Gen AI Avatar.

• Integrated Rewards across mobile and PC that give players access to VIP experiences like our Four Days of Fantastic Rewards at San Diego Comic-Con, Diamond District experience on Roblox, and Play's own treasure-hunt mini-game Diamond Valley alongside new Play Games Leagues where players can compete in their favorite games, climb leaderboards, and win Play Points rewards.

• The new Play Games Sidekick, a helpful in-game overlay that curates and organizes relevant gaming info, and provides direct access to Gemini Live for real-time AI-powered guidance in the game. We recently rolled out the open beta to developers, and we encourage you to start testing the sidekick in your games and share your feedback.

• Integrated gameplay across devices is now fully realized as Google Play Games on PC has graduated from beta to general availability, solidifying our commitment to cross-platform play and making our catalog of over 200,000 titles available across mobile and PC.

Play Games Sidekick is a new in-game overlay that gives players instant access to their rewards, offers, and achievements, driving higher engagement for your game.

To help you get the most out of this unified gaming experience, we introduced the Google Play Games Level Up program, a new way to unlock greater success for your business. For titles that meet core user experience guidelines, you can unlock a powerful suite of benefits including the ability to:

• Re-engage players on the new You tab, a new personalized destination on the Play Store that is designed to help you re-engage and retain players by showcasing content and rewards from recently played games in one dedicated space. You can utilize engagement tools in Play Console to feature your latest events, offers, and updates.

• Maximize your game's reach with prominent boosts across the store, including featuring opportunities, Play Points boosters and quests, and enhanced visibility on editorial surfaces like the Games Home and Play Points Home.

You tab is a personalized destination designed to help you re-engage and
retain players by showcasing your latest events, offers, and updates.

Unlocking more discovery and engagement for your apps and its content

Last year, we shared our vision for a content-rich Google Play that has already delivered strong results. Year-over-year, Apps Home has seen over an 18% increase in average monthly visitors with apps seeing a 9% growth in acquisitions and double-digit growth* in app spend for those monetizing on Google Play. We introduced even more updates to elevate discovery and engagement on and off the store.

• Curated spaces, launched last year, have been a success, fostering routine engagement by delivering daily, locally relevant content (such as football highlights in Brazil, cricket in India, and comics in Japan) directly to the Apps Home. Building on this, we expanded to new categories and locations, including a new entertainment-focused space in Korea.

Curated spaces make it easier to find and engage with local interests.

• We significantly increased timely, relevant content on Google Play through Spotlight and new topic browse pages. Spotlight, located at the top of Apps Home, offers seasonal content feeds-like Taylor Swift's recent album launch or holiday movie guides-in a new, immersive way to connect users with current cultural moments. Concurrently, new topic browse pages were integrated across the store in the U.S., Japan, and South Korea, allowing content deep dives into over 100,000 shows and movies.

Spotlight offers an immersive experience connecting users

with relevant apps during current cultural moments.

Last year, we introduced Engage SDK to help you deliver personalized content to users across surfaces and seamlessly guide them into the relevant in-app experiences. Integrating it unlocks surfaces like Collections, our immersive full-screen experience bringing content directly to the user's home screen. This year, we rolled out updates to expand your content's reach even further:

• Engage SDK content expanded to the Play Store this summer, enabling seamless re-engagement across Apps Home and the new You tab.

• Rolled out to more markets, including Brazil, Germany, India, Japan, and Korea.
  
  

Supporting you throughout your app lifecycle

In addition to evolving the store, we've continued to build on our powerful toolset to support you at every stage, from testing and release to growth and monetization.

Helping you deliver high-quality, trusted user experiences

We launched key updates in Android Studio and Play Console to help you build more stable and compliant apps.

• Policy insights in Android Studio help you catch potential violations early by showing in-context guidance, such as policy summaries and best practices, whenever code related to a Google Play policy is detected.

• You can now halt fully rolled-out releases to stop the distribution of problematic app versions through Play Console and the Publishing API.

• We also added new Android vitals performance metrics, including low memory kill metrics which provides device-specific insights to resolve stability problems and excessive partial wake lock metrics to help you address battery drain.

New Android vitals metrics help you resolve stability problems and address battery drain.

Boosting your productivity and workflow

We refined the Play Console experience to make managing your app and your marketing content more efficient.

• We put your most essential insights front and center with a redesigned app dashboard and overview pages.

• To repurpose creative content across Play Console more easily, we launched an asset library that lets you upload from Google Drive, organize with tags, and crop existing visuals.

• You can now automatically translate app strings with Gemini at no cost. This feature eliminates manual translation work for new releases, making updates seamless. You remain in full control with the ability to preview translations using a built-in emulator, and can easily edit or disable the service.

Translate app strings automatically with Gemini, while maintaining full control for previewing and editing.

Maximizing your revenue with secure, frictionless payments

We introduced new features focused on driving purchases and maximizing subscription revenue globally.

• We're improving purchase conversion globally with over 800 million users now ready to buy. We launched features that encourage users to set up payment methods early, provide AI-powered payment method recommendations, and expanded our payment library to support more local payment methods globally.

• To maximize recurring revenue from over 400 million paid subscriptions, we introduced multi-product checkout, allowing you to sell base subscriptions and add-ons under a simple, single transaction.

• To combat churn, we began showcasing subscription benefits in more places and provided you with more flexible options like extended grace periods and account holds for declined payments, which has proven effective in reducing involuntary churn by an average of 10%*.

To help reduce voluntary churn, we're showcasing your subscriptions benefits across Play.

Investing in our app and game community with developer programs

We're proud to invest in programs for app and game companies around the world to help you grow and succeed on Play.

• Google Play Apps Accelerator: We've opened submissions for our program that will help early-stage app companies scale their business. Selected companies from over 80 eligible countries will join a 12-week accelerator starting in March 2026, where they can learn more about creating high-quality apps, go-to-market strategies, user acquisition, and more.

Submissions are still open for our 12-week accelerator, which starts in March 2026.
Apply by January 7, 2026 for consideration.

• Indie Games Fund (Latin America): Now in its fourth year, this fund provides support to 10 promising game studios in Latin America with funding and hands-on support from Google Play. In October, we announced the 2025 recipients.

• ChangGoo Program (South Korea): Now in its seventh year, this program works with over 100 Korean mobile app and game startups to foster their growth and expansion in collaboration with the Ministry of SMEs and Startups and the Korean Institute of Startup and Entrepreneurship Development (KISED).

• Google Play x Unity Game Developer Training Program (Indonesia): The third edition launched in April, offering a 6-month online curriculum, meetups, and mentorship for Indonesian game developers in partnership with Indonesia's Ministry of Creative Economy and the Indonesian Gaming Association.

• Google Play x Unity Game Developer Training Program (India): The first India cohort kicked off in November with 500 aspiring and professional game developers. The 6-month journey provides online curriculum and meetups in partnership with GDAI and the govt of Tamil Nadu and Maharashtra.

• Google for Startups Accelerator program (India): We provided Seed to Series-A AI-powered app startups in India with insights on the latest AI advancements, mentorship, and expert guidance.

Protecting your business and our ecosystem

At the heart of all the progress we've made this year is a foundation of trust and security. We're always innovating to make Play safer for everyone-so users can trust every app they download and so you can keep building a thriving business.

To offer stronger protection for your business and users, we continued to enhance the Play Integrity API and our anti-fraud systems. On average, apps using Play Integrity features see 80% lower unauthorized usage, and our efforts have safeguarded top apps using Play Billing from $2.9 billion in fraud and abuse in the last year.

• Automatically fix user issues: New Play in-app remediation prompts in Play Integrity API automatically guide users to fix common problems like network issues, outdated Google Play Services, or device integrity flags, reducing integration complexity and getting users back to a good state faster.

• Combat repeat bad actors: Device recall is a powerful new tool that lets you store and recall limited data associated with a device, even if the device is reset, helping protect your business model from repeat bad actors.

• Strengthen revenue protection: We've introduced stronger protections against abuse, including refining pricing arbitrage detection and enhancing protection against free trial and intro pricing abuse for subscriptions, helping your business models remain profitable.

With in-app remediation prompts, Play automatically handles
a wide range of issues to guide your users back to a good state.

For a full breakdown of new ways we're keeping the ecosystem safe, check out our deep-dive blog post here.

Thank you for your partnership

This is an incredible time for Google Play. We've made huge strides together - your passion, creativity, and feedback throughout 2025 has made Play that much stronger. We're grateful to work alongside the best developer community in the world, and we look forward to unlocking even greater success together in the new year.

Happy holidays!

Sam Bright

VP & GM, Google Play + Developer Ecosystem

* Source: Internal Google data

15 Dec 2025 5:00pm GMT

Posted by Santiago Aboy Solanes - Software Engineer, Vladimír Marko - Software Engineer

The Android Runtime (ART) team has reduced compile time by 18% without compromising the compiled code or any peak memory regressions. This improvement was part of our 2025 initiative to improve compile time without sacrificing memory usage or the quality of the compiled code.

Optimizing compile-time speed is crucial for ART. For example, when just-in-time (JIT) compiling it directly impacts the efficiency of applications and overall device performance. Faster compilations reduce the time before the optimizations kick in, leading to a smoother and more responsive user experience. Furthermore, for both JIT and ahead-of-time (AOT), improvements in compile-time speed translate to reduced resource consumption during the compilation process, benefiting battery life and device thermals, especially on lower-end devices.

Some of these compile-time speed improvements launched in the June 2025 Android release, and the rest will be available in the end-of-year release of Android. Furthermore, all Android users on versions 12 and above are eligible to receive these improvements through mainline updates.

Optimizing the optimizing compiler

Optimizing a compiler is always a game of trade-offs. You can't just get speed for free; you have to give something up. We set a very clear and challenging goal for ourselves: make the compiler faster, but do it without introducing memory regressions and, crucially, without degrading the quality of the code it produces. If the compiler is faster but the apps run slower, we've failed.

The one resource we were willing to spend was our own development time to dig deep, investigate, and find clever solutions that met these strict criteria. Let's take a closer look at how we work to find areas to improve, as well as finding the right solutions to the various problems.

Finding worthwhile possible optimizations

Before you can begin to optimize a metric, you have to be able to measure it. Otherwise, you can't ever be sure if you improved it or not. Luckily for us, compile time speed is fairly consistent as long as you take some precautions like using the same device you use for measuring before and after a change, and making sure you don't thermal throttle your device. On top of that, we also have deterministic measurements like compiler statistics that help us understand what's going on under the hood.

Since the resource we were sacrificing for these improvements was our development time, we wanted to be able to iterate as fast as we could. This meant that we grabbed a handful of representative apps (a mix of first-party apps, third-party apps, and the Android operating system itself) to prototype solutions. Later, we verified that the final implementation was worth it with both manual and automated testing in a widespread manner.

With that set of hand-picked apks we would trigger a manual compile locally, get a profile of the compilation, and use pprof to visualize where we are spending our time.

Example of a profile's flame graph in pprof

The pprof tool is very powerful and allows us to slice, filter, and sort the data to see, for example, which compiler phases or methods are taking most of the time. We will not go into detail about pprof itself; just know that if the bar is bigger then it means it took more time of the compilation.

One of these views is the "bottom up" one where you can see which methods are taking most of the time. In the image below we can see a method called Kill, accounting for over a 1% of the compile time. Some of the other top methods will also be discussed later in the blog post.

Bottom up view of a profile

In our optimizing compiler, there's a phase called Global Value Numbering (GVN). You don't have to worry about what it does as a whole, but the relevant part is to know that it has a method called `Kill` that it will delete some nodes according to a filter. This is time consuming as it has to iterate through all the nodes and check one by one. We noticed that there are some cases in which we know in advance that the check will be false, no matter the nodes we have alive at that point. In these cases, we can skip iterating altogether, bringing it from 1.023% down to ~0.3% and improving GVN's runtime by ~15%.

Implementing worthwhile optimizations

We covered how to measure and how to detect where the time is being spent, but this is only the beginning. The next step is how to optimize the time being spent compiling.

Usually, in a case like the `Kill` one above we would take a look at how we iterate through the nodes and do it faster by, for example, doing things in parallel or improving the algorithm itself. In fact, that's what we tried at first and only when we couldn't find anything to do we had a "Wait a minute…" moment and saw that the solution was to (in some cases) not iterate at all! When doing these kinds of optimizations, it is easy to miss the forest for the trees.

In other cases, we used a handful of different techniques including:

• using heuristics to decide whether an optimization will fail to produce worthwhile results and therefore can be skipped

• using extra data structures to cache computed data

• changing the current data structures to get a speed boost

• lazily computing results to avoid cycles in some cases

• use the right abstraction - unnecessary features can slow down the code

• avoid chasing a frequently used pointer through many loads

How do we know if the optimizations are worth pursuing?

That's the neat part, you don't. After detecting that an area is consuming a lot of compile time and after devoting development time to try to improve it, sometimes you can't just find a solution. Maybe there's nothing to do, it will take too long to implement, it will regress another metric significantly, increase code base complexity, etc. For every successful optimization that you can see in this blog post, know that there are countless others that just didn't come to fruition.

If you are in a similar situation, try to estimate how much you are going to improve the metric by doing as little work as you can. This means, in order:

1. Estimating with a metrics you have already collected, or just a gut feeling

2. Estimating with a quick and dirty prototype

3. Implement a solution.

Don't forget to consider estimating the drawbacks of your solution. For example, if you are going to rely on extra data structures, how much memory are you willing to use?

Diving deeper

Without further ado, let's look at some of the changes we implemented.

We implemented a change to optimize a method called FindReferenceInfoOf. This method was doing a linear search of a vector to find an entry. We updated that data structure to be indexed by the instruction's id so that FindReferenceInfoOf would be O(1) instead of O(n). Also, we pre-allocated the vector to avoid resizing. We slightly increased memory as we had to add an extra field which counted how many entries we inserted in the vector, but it was a small sacrifice to make as the peak memory didn't increase. This sped up our LoadStoreAnalysis phase by 34-66% which in turns gives ~0.5-1.8% compile time improvement.

We have a custom implementation of HashSet that we use in several places. Creating this data structure was taking a considerable amount of time and we found out why. Many years ago, this data structure was used in only a few places that were using very big HashSets and it was tweaked to be optimized for that. However, nowadays it was used in the opposite direction with only a few entries and with a short lifespan. This meant that we were wasting cycles by creating this huge HashSet but we only used it for a few entries before discarding it. With this change, we improved ~1.3-2% of compile time. As an added bonus, memory usage decreased by ~0.5-1% since we weren't using as big data structures as before.

We improved ~0.5-1% of compile time by passing data structures by reference to the lambda to avoid copying them around. This was something that was missed in the original review and sat in our codebase for years. It was thanks to taking a look at the profiles in pprof that we noticed that these methods were creating and destroying a lot of data structures, which led us to investigate and optimize them.

We sped up the phase that writes the compiled output by caching computed values, which translated to ~1.3-2.8% of total compile time improvement. Sadly, the extra bookkeeping was too much and our automated testing alerted us of the memory regression. Later, we took a second look at the same code and implemented a new version which not only took care of the memory regression but also improved the compile time a further ~0.5-1.8%! In this second change we had to refactor and reimagine how this phase should work, in order to get rid of one of the two data structures.

We have a phase in our optimizing compiler which inlines function calls in order to get better performance. To choose which methods to inline we use both heuristics before we do any computation, and final checks after doing work but right before we finalize the inlining. If any of those detect that the inlining is not worth it (for example, too many new instructions would be added), then we don't inline the method call.

We moved two checks from the "final checks" category to the "heuristic" category to estimate whether an inlining will succeed or not before we do any time-expensive computation. Since this is an estimate it is not perfect, but we verified that our new heuristics cover 99.9% of what was inlined before without affecting performance. One of these new heuristics was about the needed DEX registers (~0.2-1.3% improvement), and the other one about number of instructions (~2% improvement).

We have a custom implementation of a BitVector that we use in several places. We replaced the resizable BitVector class with a simpler BitVectorView for certain fixed-size bit vectors. This eliminates some indirections and run-time range checks and speeds up the construction of the bit vector objects.

Furthermore, the BitVectorView class was templatized on the underlying storage type (instead of always using uint32_t as the old BitVector). This allows some operations, for example Union(), to process twice as many bits together on 64-bit platforms. The samples of the affected functions were reduced by more than 1% in total when compiling the Android OS. This was done across several changes [1, 2, 3, 4, 5, 6]

If we talked in detail about all the optimizations we would be here all day! If you are interested in some more optimizations, take a look at some other changes we implemented:

• Add bookkeeping to improve compilation times by ~0.6-1.6%.

• Lazily compute data to avoid cycles, if possible.

• Refactor our code to skip precomputing work when it will not be used.

• Avoid some dependent load chains when the allocator can be readily obtained from other places.

• Another case of adding a check to avoid unnecessary work.

• Avoid frequent branching on register type (core/FP) in register allocator.

• Make sure some arrays are initialized at compile time. Don't rely on clang to do it.

• Clean up some loops. Use range loops that clang can optimize better because it does not need to reload the internal pointers of the container due to loop side effects. Avoid calling the virtual function `HInstruction::GetInputRecords()` in the loop via the inlined `InputAt(.)` for each input.

• Avoid Accept() functions for the visitor pattern by exploiting a compiler optimization.

Conclusion

Our dedication to improving ART's compile-time speed has yielded significant improvements, making Android more fluid and efficient while also contributing to better battery life and device thermals. By diligently identifying and implementing optimizations, we've demonstrated that substantial compile-time gains are possible without compromising memory usage or code quality.

Our journey involved profiling with tools like pprof, a willingness to iterate, and sometimes even abandon less fruitful avenues. The collective efforts of the ART team have not only reduced compile time by a noteworthy percentage, but have also laid the groundwork for future advancements.

All of these improvements are available in the 2025 end-of-year Android update, and for Android 12 and above through mainline updates. We hope this deep dive into our optimization process provides valuable insights into the complexities and rewards of compiler engineering!

15 Dec 2025 5:00pm GMT

Posted by Matthew Forsythe , Director, Product Management, App & Ecosystem Trust and Ron Aquino Sr. Director, Trust and Safety, Chrome, Android and Play

Earlier this year, we reiterated our commitment to keeping Android and Google Play safe for everyone and maintaining a thriving environment where users can trust the apps they download and your business can flourish. We've heard your feedback clearly, from excited conversations at Play events around the world to the honest concerns on social media. You want simpler ways to make sure your apps are compliant and pass review, and need strong protections for your business so you can focus on growth and innovation. We are proud of the steps we've taken together this year, but know this is ongoing work in a complex, ever-changing market.

Here are key actions we've taken this year to simplify your development journey and strengthen protection.

Simpler ways to build safer apps from the start

This year, we focused on making improvements to the app publishing experience by reducing friction points, from the moment you write code to submitting your app for review.

• Policy guidance right where you code: We rolled out Play Policy Insights to all developers using Android Studio. This feature provides real-time, in-context guidance and policy warnings as you code, helping you proactively identify and resolve potential issues before you even submit your app for review.

• Pre-review checks to help prevent app review surprises: Last year, we launched pre-review checks in Play Console so you can identify issues early, like incomplete policy declarations or crashes, and avoid rejections. This year, we expanded these checks for privacy policy links, login credential requirements, data deletion request links, inaccuracies in your Data safety form, and more.

Stronger protection for your business and users

We are committed to providing you with powerful ways to protect your apps and users from abuse. Beyond existing tools, programs, and the performance and security enhancement that comes with every Android release, we've also launched:

• Advanced abuse and fraud protection: We made the Play Integrity API faster and more resilient, and introduced new features like Play remediation prompts and device recall in beta. Device recall is a powerful new tool that lets you store and recall limited data associated with a device, even if the device is reset, helping protect your business model from repeat bad actors.

• Tools to keep kids safe:

• • We continued to invest in protecting children across Google products, including Google Play. New Play policy helps keep our youngest users safe globally by requiring apps with dating and gambling features to use Play Console tools to prevent minors from accessing them. Our enhanced Restrict Minor Access feature now blocks the users who we determine to be minors from searching for, downloading, or making purchases in apps that they shouldn't have access to.

  • We've also been providing tools to developers to help meet significant new age verification regulatory requirements in applicable US states.

• More ways to stop malware from snooping on your app: Android 16 provides a new, powerful defense in a single line of code: accessibilityDataSensitive. This flag lets you explicitly mark views in your app as containing sensitive data and block malicious apps from seeing or performing interactions on it. If you already use setFilterTouchesWhenObscured(true) to protect your app from tapjacking, your views are automatically treated as sensitive data for accessibility for an instant additional layer of defense with no extra work.

Smoother policy compliance experience

We're listening to your concerns and proactively working to make the experience of Play policy compliance and Android security requirements more transparent, predictable, and accessible for all developers. You asked for clarity, fairness, and speed, and here is what we launched:

• More support when you need it: Beyond the webinars and resources that we share, you told us you needed more direct policy help to understand requirements and get answers. Next week, we'll add a direct way for you to reach our team about policy questions in your Play Console. You'll be able to find this new, integrated support experience directly within your Play Console via the "Help" section. We also expanded the Google Play Developer Help Community to more languages, like Indonesian, Japanese, Korean, and Portuguese.

• Clearer documentation: You asked for policy that's easier to understand. To help you quickly grasp essential requirements, we've introduced a new Key Considerations section across several policies (like Permissions and Target API Level) and included concise "Do's & Don'ts" and easier-to-read summaries.

• More transparent appeals process: We introduced a 180-day appeal window for account terminations. This allows us to prioritize and make decisions faster for developers who file appeals.

• Android developer verification design changes: To support a diverse range of users and developers, we're taking action on your feedback.

• • First, we're creating a dedicated free account type to support students and hobbyists who want to build apps just for a small group, like family and friends. This means that you can share your creations to a limited number of devices without needing to go through the full developer verification process.

  • We're also building a flow for experienced users to be able to install unverified apps. This is being carefully designed to balance providing choice with prioritizing security, including clear warnings so users fully understand the risks before choosing to bypass standard safety checks.

The improvements we made this year are only the beginning. Your feedback helps drive our roadmap, and it will continue to inform future refinements to our policies, tools, experiences, and ensuring Android and Google Play remain the safest and most trusted place for you to innovate and grow your business.

Thank you for being our partner in building the future of Android.

11 Dec 2025 10:26pm GMT