<br />

Use the App Performance Score to calculate your overall performance score
and discover opportunities for improvement. The App Performance Score provides a
standardized framework to measure performance with minimal in-depth technical
tasks.

It guides engineering and product teams to assess technical performance of any
given Android app. After the assessment is complete, an evaluation and
recommended actions help to identify and prioritize the most important areas for
performance improvement.
| **Preview:** This page contains the first iteration of the App Performance Score.
|
| - Scoring, evaluation and recommendations are likely to change in the future.
| - Recommendations and guidance provided has curated with performance impact in mind.
| - Tools and guidance in the recommendations are stable and can help to improve app startup and rendering performance.

*** ** * ** ***

### Introduction

The App Performance Score provides app developers with static and dynamic
assessments. Both can be conducted individually and provide unique insights into
an app's performance behavior. These insights are coupled with actionable
recommendations which can help to improve the status quo and elevate the app's
performance.

A score between 0 and 100 is provided to help gauge the overall performance.
A lower number means more room to improve.

Use the score and recommendations for each item to direct engineering efforts
into areas where high performance gains can be achieved. When recommendations
have been applied, take the assessment again and see how the score has improved.

| Dynamic score | Static score |
|---|---|
| The application's runtime behavior is used to assess performance characteristics. The dynamic performance score is a direct reflection of how well an app performs on a specific device. | The application is statically assessed to evaluate performance predictors based on use of best practices and tooling adoption. The static performance score highlights tools with high impact on app performance. No runtime evaluation is needed for this score. |
| [checklist Jump to dynamic score](https://developer.android.com/topic/performance/app-score#dynamic-score) | [checklist Jump to static score](https://developer.android.com/topic/performance/app-score#static-score) |

<br />

*** ** * ** ***

<br />

![](https://developer.android.com/static/images/picto-icons/lightning.svg)

## Dynamic App Performance Score

During dynamic assessment of the App Performance Score, runtime data are used to
evaluate an app's performance on a specific device.

The dynamic assessment requires a physical device for a realistic performance
evaluation. The score will vary depending on the device's capabilities. Assess
the performance on multiple devices to get a better understanding how users are
impacted by performance shortcomings.
| **Tip:** Use lower end devices to exaggerate performance issues. This will result in an overall lower score and emphasize areas that can be improved.

The current dynamic app score categories and assessment criteria are outlined in
the following table.

| Category | Assessment criteria |
|---|---|
| Application startup | Measured duration between app startup and the app becoming interactive [TTFD](https://developer.android.com/topic/performance/vitals/launch-time#time-full). |
| Rendering performance | Percentage of slow and frozen frames for scrolling, animating and full screen renders. |

| **Instructions to measure app startup performance**
|
| - Always test cold startup time.
| - Ensure the app is killed between tests.
| - We recommend one of these methods to calculate performance metrics
|   - Use the [macrobenchmarks](http://developer.android.com/topic/performance//topic/performance/benchmarking/macrobenchmark-overview) for fully automatable and highly accurate results.
|   - Profile app launch time using [system tracing](http://developer.android.com/topic/performance/tracing) for accurate results.
|   - Manual testing will yield imprecise results that should be refined later.
| **Tip:** Repeat the measurement for more accurate results. Kill the app between tests.
Startup performance

### Measure app startup time from the launcher

1. Open the app from the launcher icon
2. Measure the time it takes for the app to become interactive  
Make an assessment Slower than 5 seconds (0 points) Between 5 and 4 seconds (5 points) Between 4 and 3 seconds (10 points) Between 3 and 2 seconds (20 points) Between 2 and 1 seconds (25 points) Less than 1 second (30 points)

| Evaluation | Recommendation |
|---|---|---|
| Slower than 5 seconds (0 points) | **Extremely slow app startup** App startup this slow can trigger [ANR](http://developer.android.com/topic/performance/vitals/anr) in some scenarios. Even without ANR, users can be very frustrated by startup times in this range which negatively impacts user satisfaction, retention and business metrics. | **Urgently invest engineering resources to improve this application's startup time.** The biggest app startup improvement potential can be realized by adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. |
| Between 5 and 4 seconds (5 points) | **Very slow app startup** Users likely find waiting for this app to start up frustrating. Faster app startup is directly related to improved business and user satisfaction metrics. | **Treat app startup as high priority and immediately invest engineering time in this area.** Adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations), then retake the assessment for an updated score. If you already adopted these, follow the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. |
| Between 4 and 3 seconds (10 points) | **Slow app startup** Users of this app will notice a delay in startup time. Faster app startup improves user driven metrics such as retention and ratings. | **Invest engineering resources to continue driving down app startup times.** If you haven't yet, adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations), then retake the assessment for an updated score. Check out the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. |
| Between 3 and 2 seconds (20 points) | **App startup time below user expectations** Many users will find app startup time in this range acceptable but not meeting their quality expectations. Faster app startup is directly related to improved business metrics. Look into further improving the app startup time. | **Start or continue investing engineering resources into app startup.** Make use of [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) to improve app startup and runtime performance by a big margin. If you already adopted these, follow the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. |
| Between 2 and 1 seconds (25 points) | **Satisfying app startup time** Users likely are satisfied with this app's startup time. While there is still room for improving in this area, it's not urgent to take action. | **Adopt high impact tools, then focus on other performance areas.** Monitor app startup times closely and make sure they don't regress. You can use [macrobenchmarks](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview) to achieve this. Schedule integration of [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), code optimizations via [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) as these are the biggest impact tools to improve app startup time. Also check out the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. Take this evaluation on a low-spec device (such as an [Android Go](http://developer.android.com/guide/topics/androidgo) device) to get a better understanding of app startup time on these devices. |
| Less than 1 second (30 points) | **Above expectations app startup time.** This app startup time is so fast, many users won't even notice it. Well done! | **Keep up the brilliant work. Continue monitoring app startup time and react to regressions immediately.** To further improve app startup times, check out the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization). Adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) impacts not only app startup time but also runtime performance. If you haven't done so, schedule time to adopt them. Take this evaluation on a low-spec device to get a better understanding of the app startup time for these devices. |

Startup performance

### Measure app startup time from a notification

1. Trigger a notification for the app
2. Open the app from the notification
3. Measure the time it takes for the app to become interactive  
Make an assessment Slower than 5 seconds (0 points) Between 5 and 4 seconds (2 points) Between 4 and 3 seconds (5 points) Between 3 and 2 seconds (10 points) Between 2 and 1 seconds (15 points) Less than 1 second (20 points) No notification entry point (20 points)

| Evaluation | Recommendation |
|---|---|---|
| Slower than 5 seconds (0 points) | **Extremely slow app startup** App startup this slow can trigger [ANR](http://developer.android.com/topic/performance/vitals/anr) in some scenarios. Even without ANR users can be very frustrated by startup times in this range which negatively impacts user satisfaction, retention and business metrics. | **Treat this notification entry point as high priority and immediately invest engineering time in this area.** The biggest app startup improvement potential can be realized by adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. |
| Between 5 and 4 seconds (2 points) | **Very slow app startup** Users likely find this delay in app startup time frustrating. Faster app startup is directly related to improved business and user satisfaction metrics. | **Urgently invest engineering resources to improve this startup time.** Adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations), then retake the assessment for an updated score. If you already adopted these, follow the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. |
| Between 4 and 3 seconds (5 points) | **Slow app startup** Users of this app will notice a delay in startup time. Faster app startup improves user driven metrics such as retention and ratings. | **Invest engineering resources to continue driving down app startup times.** If you haven't yet, adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) for this notification, optimizations via [R8](http://developer.android.com/build/shrink-code) and incldue the relevant code in a [Startup Profile via Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations), then retake the assessment for an updated score. Check out the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. |
| Between 3 and 2 seconds (10 points) | **App startup time below user expectations** Many users will find app startup time in this range acceptable but not meeting their quality expectations. Faster app startup is directly related to improved business metrics. Look into further improving the app startup time. | **Start or continue investing engineering resources into this entry point.** Make use of [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) to improve app startup and runtime performance by a big margin. If you already adopted these, follow the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. |
| Between 2 and 1 seconds (15 points) | **Satisfying app startup time** Users likely are satisfied with this app's startup time. While there is still room for improving in this area, it's not urgent to take action. | **Adopt high impact tools, then focus on other performance areas.** Monitor app startup times closely and make sure they don't regress. You can use [macrobenchmarks](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview) to achieve this. Schedule integration of [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), code optimizations via [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) as these are the biggest impact tools to improve app startup time. Also check out the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization) for other ways to improve app startup times. Take this evaluation on a low-spec device to get a better understanding of app startup time on these devices. |
| Less than 1 second (20 points) | **Above expectations app startup time.** This app startup time is so fast, many users won't even notice it. Well done! | **Keep up the brilliant work with your app's startup time. Continue monitoring app startup time and react to regressions immediately.** To further improve app startup times, check out the [app startup guidance](http://developer.android.com/topic/performance/appstartup/analysis-optimization). Adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) impacts not only app startup time but also runtime performance. If you haven't done so, schedule time to adopt them. Take this evaluation on a low-spec device to get a better understanding of the app startup time for these devices. |
| No notification entry point (20 points) | **Nothing to do here** This app does not use notifications as entry points. So there is nothing to optimize here. | **Take this assessment again when notifications are being used** In the meantime, check out other areas of app performance to improve. |

*** ** * ** ***

| **Instructions to measure rendering performance:**
|
| - Only measure by feel if you don't have any other tools at hand.
| - Use [macrobenchmarks](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview) for fully automatable and highly accurate results.
| - Use the [HWUI layer](http://developer.android.com/topic/performance/rendering/inspect-gpu-rendering) to see slow and frozen frames highlighted on screen.
| - Profile rendering time using [system tracing](http://developer.android.com/topic/performance/tracing) for accurate results.
Rendering performance

### Measure animation and scroll rendering

1. Open the app and navigate to the target screen
2. Perform a few interactions such as scrolling and clicking
3. Measure the percentage of slow and frozen frames during these interactions  
Make an assessment Frequent ANR block interactions and animations (ANR or \> 20 %) (0 points) Animations block user interaction (20 - 15 %) (1 points) Noticeable animation issues throughout (15 - 10 %) (5 points) Noticeable animation issues in a few areas (5 - 10 %) (10 points) Mostly smooth rendering (1 - 5 %) (20 points) Smooth rendering throughout (\< 1 %) (30 points)

| Evaluation | Recommendation |
|---|---|---|
| Frequent ANR block interactions and animations (ANR or \> 20 %) (0 points) | **Unbearable rendering experience** A user experience at this level of performance is very frustrating to users. Low user satisfaction is directly linked to lower business performance, retention and user ratings. | **Urgenty adopt high impact tools.** Immediately schedule adoption of high impact tools such as [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Then retake the assessment. Afterwards you can check out the follow the [app performance guidance](http://developer.android.com/topic/performance/overview) for other ways to improve rendering performance. |
| Animations block user interaction (20 - 15 %) (1 points) | **Frame drops are highly noticeable** Highly noticeable frame drops result in lower app ratings and less than optimal retention rates. [Collect traces](http://developer.android.com/topic/performance/tracing/on-device) to inspect hot spots for slow frames and work your way through the list. | **Adopt high impact tools to improve rendering performance.** The biggest improvement potential can be realized by adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. For further help, follow the follow the [app performance guidance](http://developer.android.com/topic/performance/overview). |
| Noticeable animation issues throughout (15 - 10 %) (5 points) | **Below average rendering performance** The rendering issues surfaced are noticeable to users. This will lead to lower than optimal user satisfaction and ratings as well as business impact. If this was tested on a high end device, noticeable slow frames will be unbearable on a low end device. | **Improve rendering performance by adopting high impact tools.** The biggest improvement potential can be realized by adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. For further help, follow the follow the [app performance guidance](http://developer.android.com/topic/performance/overview). |
| Noticeable animation issues in a few areas (5 - 10 %) (10 points) | **Rendering issues are a noticeable source of user frustration.** A few slow frames are all it takes to disappoint user's quality expectations. Unsatisfied users are more likely abandon apps. | **Drive down rendering issues by adopting high impact tools.** Invest in improving this area to positively impact user ratings and business metrics. The biggest improvement potential can be realized by adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. For further help, follow the follow the [app performance guidance](http://developer.android.com/topic/performance/overview). |
| Mostly smooth rendering (1 - 5 %) (20 points) | **Smooth rendering is a great user experience.** Since there are still some slow frames, users might notice them. Regardless, this is a great user experience, especially on low end devices. | **Continue driving down rendering issues to further improve user satisfaction.** Improving gets more challenging at this level. Continue driving down rendering issues to further improve user satisfaction. Ensure that there are no regressions and collect automated benchmarks for your most used devices and user journeys. Test on low end devices and fix problems there. When it's good there, it'll be great on a high end device. Invest in adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. For further help, follow the follow the [app performance guidance](http://developer.android.com/topic/performance/overview). |
| Smooth rendering throughout (\< 1 %) (30 points) | **Brilliant rendering performance.** Congratulations! This app's rendering performance is great. There is no immediate need for action. Consider taking the evaluation on a low end device to get a better understanding of the rendering performance on these devices. | **This area looks great, no immediate need for action.** Improving gets more challenging at this level. Continue driving down rendering issues to further improve user satisfaction. Ensure that there are no regressions and collect automated benchmarks for your most used devices and user journeys. Test on low end devices and fix problems there. When it's good there, it'll be great on a high end device. Invest in adopting [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles), [R8](http://developer.android.com/build/shrink-code) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). Adopt these technologies and retake the assessment. For further help, follow the follow the [app performance guidance](http://developer.android.com/topic/performance/overview). |

Rendering performance

### Measure full screen rendering issues

1. Open the app and navigate to the target screen
2. Measure how long it takes for the screen to be fully rendered and become interactive  
Make an assessment Extremely noticeable (\> 3 second) (0 points) Very noticeable (1 to 3 seconds) (1 points) Noticeable (500ms to 1 second) (5 points) Slightly noticeable (100 to 500 ms) (10 points) Almost not noticeable (100 to 50 ms) (15 points) Not noticeable (less than 50 ms) (20 points)

| Evaluation | Recommendation |
|---|---|---|
| Extremely noticeable (\> 3 second) (0 points) | **Full screen renders should be smooth. This one is not.** Keeping an app responsive is key for a great user experience. Waiting for multiple seconds after an interaction is frustrating to users. This is a great opportunity to improve user satisfaction and business metrics. | **Urgently invest in improving this full screen render.** Make sure to generate a [Baseline Profile](http://developer.android.com/topic/performance/baselineprofiles) for this full screen render and check that [R8](http://developer.android.com/build/shrink-code) optimizations are enabled here. These areas are most impactful to improving app performance. Then come back to take another assessment for more guidance. |
| Very noticeable (1 to 3 seconds) (1 points) | **Slower than optimal response time.** Full screen renders that are responding to user interactions should be as fast as possible. Slower than optimal rendering results in lower app ratings and is a source of user frustration. As developer your focus should be to improve user satisfaction. This is a great opportunity to improve user satisfaction and business metrics. | **Invest engineering efforts to improve this full screen render.** Make sure to generate a [Baseline Profile](http://developer.android.com/topic/performance/baselineprofiles) for this full screen render and check that [R8](http://developer.android.com/build/shrink-code) optimizations are enabled here. These areas are most impactful to improving app performance. You can also collect [system traces](http://developer.android.com/topic/performance/tracing) to inspect hot spots for slow frames and work your way through the list. Then come back to take another assessment for more guidance. |
| Noticeable (500ms to 1 second) (5 points) | **This full screen render is on the slow side.** Continue improving performance of this transition for a better score! Noticeable slow frames on a high end device will be unbearable on a low end device. | **Continue investing engineering time to improve this transition.** Test on low end devices and fix problems there. When it's good there, it'll be great on a high end device. Make sure to generate a [Baseline Profile](http://developer.android.com/topic/performance/baselineprofiles) for this full screen render and check that [R8](http://developer.android.com/build/shrink-code) optimizations are enabled here. These areas are most impactful to improving app performance. To get more information for this specific render, you can also collect [system traces](http://developer.android.com/topic/performance/tracing) to inspect hot spots for slow frames and work your way through the list. Then come back to take another assessment for more guidance. |
| Slightly noticeable (100 to 500 ms) (10 points) | **This almost looks well polished** Check if this full screen render can be improved. While a single slow full screen render is not overly dramatic, ensure that this is not a systemic issue which is impacting user satisfaction negatively. A few slow frames are all it takes to disappoint user's quality expectations. | **Investigate this full screen render to see if it can be improved.** Use [system traces](http://developer.android.com/topic/performance/tracing) to inspect hot spots for slow frames and work your way through the list. Collecting and evaluating these can also be automated with the [macrobenchmark library](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview) If you havent, adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) and [R8 optimizations](http://developer.android.com/build/shrink-code). Test on low end devices and fix problems there. When it's good there, it'll be great on a high end device. |
| Almost not noticeable (100 to 50 ms) (15 points) | **This full screen render is almost perfect.** Some power users still might notice transitions taking up to 100 milliseconds. This is a great result. Make sure to also test on low end devices to ensure that users aren't impacted by this transition. | **Ensure users are happy and look for other areas to improve.** This full screen render result is almost perfect. Most users will be very happy with this performance. Make sure that this is also the case on low end devices. If you want to improve further, look into [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) and [R8 optimizations](http://developer.android.com/build/shrink-code). Also check out the [app performance guidance](http://developer.android.com/topic/performance/overview) for more information on rendering performance. |
| Not noticeable (less than 50 ms) (20 points) | **This is a stellar result.** Less than 50 milliseconds for a full screen render is remarkable and a great user experience. While you might still be able to improve this, at this point you're looking at marginal gains. | **Keep up the stellar performance.** Look for app performance improvements in other areas. Continue monitoring to catch regressions early on. You can automate monitoring and catch regressions by using the the [macrobenchmark library](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview). |

![](http://developer.android.com/static/images/picto-icons/lightning.svg)  

## **0 out of 100 points**

Dynamic App Performance Score

(0/4 questions answered)

<br />

*** ** * ** ***

<br />

![](https://developer.android.com/static/images/picto-icons/layout.svg)

## Static App Performance Score

The static App Performance Score is calculated based on the usage of highly
impactful tools and best practices. To correctly score an app's static
performance indicators, access to the project's source code is required.

The criteria listed in the following table are used to assess and generate the
static App Performance Score.

| Category | Assessment criteria |
|---|---|
| Build time improvements | - App uses latest version of the [Android Gradle Plugin](https://developer.android.com/build/gradle-build-overview) to unlock access to performance enhancing tools - [Minification and optimizations](https://developer.android.com/build/shrink-code) enabled with full mode R8. Exceptions are minimal and limited to necessary areas. |
| Startup performance | - [Baseline Profiles](https://developer.android.com/topic/performance/baselineprofiles/overview) are found in the app and applied correctly for app startup - Baseline Profiles cover one or more user journeys - Startup Profiles applied to apply [Dex Layout Optimizations](https://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) |
| Compose adoption | App uses latest stable version of [Compose](https://developer.android.com/compose) |
| Monitoring and optimization | [`FullyDrawnReporter`](https://developer.android.com/reference/kotlin/androidx/activity/FullyDrawnReporter) or [`reportFullyDrawn`](https://developer.android.com/reference/android/app/Activity#reportFullyDrawn()) is used at an appropriate time |

| **Instructions for static app performance score**
|
| - For each item in this assessment, select the option that best matches the current state of the app.
| - Check the app's source code and match the requested criteria to the best of your knowledge.
| - If you're unsure about an answer, choose the worst case option.
Holistic improvements

### Assess Android Gradle Plugin version adoption

The Android Gradle Plugin (AGP) is used to build Android apps. Many performance enhancing tools depend on new versions of the AGP. To access the most recent improvements, apps should use the latest version of AGP.  
Make an assessment AGP 7.2 and below (0 points) AGP 7.3 (1 points) AGP 7.4 - 8.1 (5 points) AGP 8.2 - 8.5 (15 points) AGP 8.6+ (20 points)

| Evaluation | Recommendation |
|---|---|---|
| AGP 7.2 and below (0 points) | **Many performance tools not available or outdated.** Versions of AGP up to 7.2 have no support for Baseline Profiles and no support for Startup Profiles. Minification and optimization tooling is also outdated and does not provide more recent performance improvements. This is a huge missed opportunity in terms of performance impact for app startup and runtime performance. | **Urgently upgrade to a newer version of AGP for improved performance tooling support.** By upgrading to a newer version of AGP, you will get access to the latest performance tooling. This will allow you to improve your app's performance and user satisfaction. Check out the [AGP upgrade assistant](http://developer.android.com/build/agp-upgrade-assistant) guidance to learn about upgrading to a newer version of AGP. |
| AGP 7.3 (1 points) | **Very limited support for high impact performance tooling.** The Android Gradle Plugin (AGP) 7.3 provides basic support for Baseline Profiles. While Baseline Profiles work this app won't be able to make the most of it. Also Startup Profiles are not supported at this version. Minification and optimization tooling is also outdated and does not provide recent performance improvements. This is a missed performance opportunity for app startup and runtime. | **Upgrade to a newer version of AGP for improved performance tooling support.** The major version bump from 7 to 8 can be daunting but is worth the investment from a performance perspective. By upgrading to a newer version of AGP, you will get access to the latest performance tooling. With this you can expect significant startup and runtime perfomrance improvements. This will allow you to improve your app's performance and user satisfaction. Check out the [AGP upgrade assistant](http://developer.android.com/build/agp-upgrade-assistant) guidance to learn about upgrading to a newer version of AGP. |
| AGP 7.4 - 8.1 (5 points) | **Limited support for high impact performance tooling.** The Android Gradle Plugin (AGP) versions 7.4 to 8.1 have support for Baseline Profiles. From AGP 8.0 onwards Baseline Profiles can be used with a dedicated Gradle plugin. Startup Profiles are not supported until AGP 8.2. Minification and optimization tooling is also outdated and does not provide more recent performance improvements. | **Upgrade to a newer version of AGP at your earliest convenience.** The major version bump from 7 to 8 can be daunting but is worth the investment from a performance perspective. By upgrading to a newer version of AGP, you will get access to the latest performance tooling. This will allow you to improve your app's startup and runtime performance alongside user satisfaction. Check out the [AGP upgrade assistant](http://developer.android.com/build/agp-upgrade-assistant) guidance to learn about upgrading to a newer version of AGP. |
| AGP 8.2 - 8.5 (15 points) | **Most high impact performance tooling unlocked.** Baseline Profiles and Startup Profiles are fully available when using [version 8.2 or higher](http://developer.android.com/topic/performance/baselineprofiles/overview#recommended-versions) of the Android Gradle Plugin. You can also use the [Baseline Profiles Gradle Plugin](http://developer.android.com/topic/performance/baselineprofiles/configure-baselineprofiles). Under the hood improvements through R8 optimizations are also recent and provide high impact. Upgrade to a more recent version of AGP to see improved startup and runtime performance as it also brings in a newer version of R8. | **Keep up to date with AGP releases.** Newer versions of AGP will keep the app up to date with the latest performance tooling. This will allow you to improve your app's performance and user satisfaction. App startup and runtime performance can be improved through under the hood improvements of R8, Baseline Profiles and Dex Layout Optimizations. |
| AGP 8.6+ (20 points) | **Fully unlocked high impact performance tooling support** By being on the latest version of AGP, this app is able to fully utilize the latest performance tooling. Under the hood improvements through [R8](http://developer.android.com/build/shrink-code), [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) and [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) are fully supported. Ensure to use these tools to improve your app's performance and user satisfaction. | **Keep up the good work.** Stay up to date with the latest AGP releases to ensure that the app is always using the latest performance tooling. Make sure your [Startup Profile](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) is correctly configured and your [Baseline Profile](http://developer.android.com/topic/performance/baselineprofiles/create-baselineprofile target=) covers the most relevant user journeys. Also verify that your [R8 configuration](http://developer.android.com/build/shrink-code) is working as intended. Check out the overall [performance guidance](http://developer.android.com/performance) to see how your app runtime performance can be improved. |

Holistic improvements

### Assess Minification and optimization using R8

The R8 compiler offers performance improvements across many areas. App size, startup time, runtime rendering, memory usage, crashes, ANR and more are improved by applying minification and optimization techniques. To make the most of these improvements, apps should use R8 in [full mode](http://developer.android.com/build/shrink-code#full-mode) to minify and optimize their code.  
Make an assessment Not enabled (0 points) Compatibility mode or major exceptions (-dontoptimize, -dontshrink) (5 points) R8 full mode, minified, optimized and resource shrinking (20 points)

| Evaluation | Recommendation |
|---|---|---|
| Not enabled (0 points) | **This app is missing out on a lot of performance improvements.** Not using [code shrinking and optimization via R8](http://developer.android.com/build/shrink-code) is a huge missed opportunity to improve app performance. Many under the hood improvements are only available when R8 is enabled. | **Urgently enable R8 to unlock major performance improvements.** Enable [R8](http://developer.android.com/build/shrink-code) optimizations as soon as possible. This will unlock a lot of performance improvements. Then come back to take another assessment for more guidance. |
| Compatibility mode or major exceptions (-dontoptimize, -dontshrink) (5 points) | **Disabling optimizations is a huge missed opportunity to improve app performance.** This app's runtime performance is not fully optimized. This is a huge missed opportunity to improve app performance. | **Unlock performance potential by enabling R8 optimizations.** Enable [R8](http://developer.android.com/build/shrink-code) optimizations as soon as possible and remove any -dontoptimize and -dontshrink exceptions. This will also unlock the ability to enable other optimizations, like [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). After R8 is enabled in full mode, come back to take another assessment for more guidance. |
| R8 full mode, minified, optimized and resource shrinking (20 points) | **High performance potential unlocked.** By enabling [R8](http://developer.android.com/build/shrink-code) optimizations, your app is in a great spot for performance improvements that are provided through optimization, obfuscation and code shrinking. This app is ready to realize more startup performance improvements by relying on [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations). | **Ensure that keep rules are up to date.** As the app continues to evolve, [R8](http://developer.android.com/build/shrink-code) keep rules need to be updated to ensure that the app is still fully optimized. Focus performance improvement efforts on other areas. Have you looked at [Startup Profiles and Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations)? |

Startup performance

### Assess Baseline Profile usage for app startup

[Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles/overview) improve code execution speed from the first launch providing performance enhancements for every new app install and every app update. This profile-guided optimization (PGO) lets apps optimize startup, reduce rendering issues, and improve overall runtime performance from the first launch for end users. Is a Baseline Profile created and used for app startup?  
Make an assessment None / Unknown (0 points) Manually, once or infrequently (2 points) Manually for each release (5 points) Automated for each release (15 points) Automated for nightly builds and releases (20 points)

| Evaluation | Recommendation |
|---|---|---|
| None / Unknown (0 points) | **Not having a baseline profile is a huge missed opportunity.** Baseline Profiles can improve first launch code execution speed by around 30% by avoiding interpretation and just-in-time (JIT) compilation steps for included code paths. Check if your app has a baseline profile and make sure to adopt the technology if it doesn't. | **Urgently adopt Baseline Profiles.** [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) improve first launch code execution speed by about 30% by avoiding interpretation and just-in-time (JIT) compilation steps for included code paths. Check out the guidance on how to adopt them and retake the assessment for an updated score. |
| Manually, once or infrequently (2 points) | **Automation is key to keeping baseline profiles up to date.** Updating baseline profiles manually can easily slip between the cracks. Especially if it's only done on a one-off basis. Baseline Profiles should be freshly generated for each relase to maximize performance gain potential for app startup and runtime performance. | **Invest in automating Baseline Profile creation.** The [Baseline Profile Gradle plugin](http://developer.android.com/topic/performance/baselineprofiles/configure-baselineprofiles) is the recommended way to automate Baseline Profile creation. It can be configured to generate a fresh profile for specific build types such as variants or release builds automatically. Profile generation must be automated to take advantage of Dex Layout Optimization. |
| Manually for each release (5 points) | **Automation is key to keeping baseline profiles up to date.** Updating baseline profiles manually can easily slip between the cracks. And a stale baseline profile does not help to improve app startup or runtime performance. | **Invest in automating Baseline Profile creation.** The [Baseline Profile Gradle plugin](http://developer.android.com/topic/performance/baselineprofiles/configure-baselineprofiles) is the recommended way to automate Baseline Profile creation. It can be configured to generate a fresh profile for specific build types such as variants or release builds automatically. |
| Automated for each release (15 points) | **Automation makes it easy to keep baseline profiles up to date.** A baseline profile that is kept up to date is a great way to improve app startup and runtime performance. Doing this for each release automatically is a nearly perfect way to ensure high quality baseline profiles. | **Keep baseline profile coverage high. Consider nightly profile generation.** Baseline Profiles are only useful if they are kept up to date. Consider generating them nightly to catch issues early and ensure that profile generation works well when a release is needed. Check out the [Baseline Profile Gradle plugin](http://developer.android.com/topic/performance/baselineprofiles/configure-baselineprofiles) for how to further automate Baseline Profile creation. |
| Automated for nightly builds and releases (20 points) | **This is the best way to keep baseline profiles up to date.** A Baseline Profile that's generated nightly and for each release is kept up to date and is ready to be used to improve app startup and runtime performance whenever a release is cut. This preparedness gives your app an edge on app performance. Well done! | **Continue improving Baseline Profile coverage.** You have mastered automating Baseline Profile generation for this app. Keep up the good work. Ensure that the user journeys covered by the Baseline Profile are also updated regularly and expanded as the app continues to grow. This will ensure that the Baseline Profile is always up to date and ready to be used to improve app startup and runtime performance. |

Startup performance

### Assess Baseline Profiles usage for user journeys

Baseline Profiles remove the need to run JIT compilation while a feature is used. This improves runtime rendering performance. Adding Baseline Profiles for critical user journeys can improve the overall app performance.
How many user journeys are covered by Baseline Profiles?  
Make an assessment None / Unknown (0 points) App startup +1 user journey (5 points) App startup +2 user journeys (10 points) App startup +3 user journeys (15 points)

| Evaluation | Recommendation |
|---|---|---|
| None / Unknown (0 points) | **Missing out on runtime performance improvements.** App runtime performance can be improved by adopting Baseline Profiles for critical user journeys. By only adopting Baseline Profiles for app startup, you are missing out on a great opportunity to improve runtime performance and user satisfaction. | **Urgently add Baseline Profiles to improve runtime performance.** Adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) for app startup and critical user journeys. These are journeys that are used by a large number of users and are critical to the app's functionality. Come back and retake the assessment for an updated score and more guidance. |
| App startup +1 user journey (5 points) | **Missing out on runtime performance improvements.** App runtime performance can be improved by adopting Baseline Profiles for critical user journeys. By only adopting Baseline Profiles for app startup or a single user journey, you are missing out on a great opportunity to improve runtime performance and user satisfaction. | **Adopt Baseline Profiles for more user journeys.** Adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) for more user journeys. By doing this the app will be continue to improve runtime performance and user satisfaction. Come back and retake the assessment for an updated score and more guidance. |
| App startup +2 user journeys (10 points) | **Baseline Profiles offer more performance improvements.** By adopting Baseline Profiles for more user journeys, this app has potential to improve runtime performance and user satisfaction.App runtime performance can be improved by adopting Baseline Profiles for critical user journeys. By only adopting Baseline Profiles for app startup or a few user journeys, you are missing out on a great opportunity to improve runtime performance and user satisfaction. | **Continue adopting Baseline Profiles for more user journeys.** Identify more user journeys that are critical to the app's functionality and adopt [Baseline Profiles](http://developer.android.com/topic/performance/baselineprofiles) for these. By doing this the app will be continue to improve runtime performance and user satisfaction. Come back and retake the assessment for an updated score and more guidance. |
| App startup +3 user journeys (15 points) | **Outstanding Baseline Profile coverage.** Covering app startup and several critical user journeys with Baseline Profiles is a great way to improve performance and user satisfaction. There might be more user journeys that can be covered by Baseline Profiles. But this app is already in a great shape in terms of Baseline Profile coverage. Keep up the good work. | **Expand Baseline Profile coverage to unlock full performance potential.** Continue driving [Baseline Profile](http://developer.android.com/topic/performance/baselineprofiles) adoption. Consider improving [R8](http://developer.android.com/build/shrink-code) adoption to improve code size and overall app runtime performance. Also consider adopting [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) to further improve app startup performance. |

Startup performance

### Dex Layout Optimizations using Startup Profiles

Startup Profiles are used by the build system to further optimize the classes and methods they contain by improving the layout of code in your APK's DEX files. With Startup Profiles, your app startup is usually between 15% and 30% faster than with Baseline Profiles alone.
Does the app use [Startup Profiles](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) to optimize the dex layout? **Important:** Dex Layout Optimizations using Startup Profiles require R8 in full mode.  
Make an assessment Unused / Unknown (0 points) Main entry point (10 points) Most entry points (15 points)

| Evaluation | Recommendation |
|---|---|---|
| Unused / Unknown (0 points) | **Huge missed opportunity to improve app startup performance.** Startup Profiles are used by the build system to further optimize the classes and methods they contain by improving the layout of code in your APK's DEX files. With Startup Profiles, your app startup is usually between 15% and 30% faster than with Baseline Profiles alone. Startup Profiles are used to improve app startup performance. By not adopting [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) via Startup Profiles, this app is missing out on a great opportunity to improve app startup performance and user satisfaction. | **Urgently invest in adopting Startup Profiles.** Adopt [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) via Startup Profiles. This will improve app startup performance and user satisfaction. Using Dex Layout Optimziations requires the use of AGP 8.2 or newer, and enabling minification/R8. |
| Main entry point (10 points) | **Optimized startup performance for the main entry point.** Using Startup Profiles for the main entry point is a great way to improve app startup performance. The improved app performance is positively impacting user experience. Keep up the good work. | **Consider covering more entry points.** The main app entry point is the most important one to cover for a Startup Profile. If this app has more entry points, consider covering them with [Startup Profiles](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) as well. This could be notifications or supplementary launcher icons. |
| Most entry points (15 points) | **Covering the most used entry points is a great way to improve app startup performance.** Optimized startup experience is great for user satisfaction. By adopting Startup Profiles for most entry points, this app is in a great shape in terms of startup performance from a tooling perspective. Keep up the good work. | **Investigate other performance improvements and keep regressions at bay.** Ensure that the Startup Profile is generated automatically for each release build by automating the [Dex Layout Optimizations](http://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations) task with the [Baseline Profiles Gradle plugin](http://developer.android.com/topic/performance/baselineprofiles/configure-baselineprofiles). Continue monitoring app startup performance with the [macrobenchmarks](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview) |

Compose adoption

### Compose adoption

More recent versions of [Jetpack Compose](http://developer.android.com/compose) offer performance improvements over previous versions. To get access to these improvements, apps should use the latest version of Compose. Does the app use the latest stable version of Jetpack Compose?  
Make an assessment Not using Compose (5 points) Compose 2022.10.00 - 2024.08.00 (1 points) Compose 2024.01.00 - 2025.07.01 (2 points) Compose 2025.08.00 or newer (5 points)

| Evaluation | Recommendation |
|---|---|---|
| Not using Compose (5 points) | **Start using Compose** Jetpack Compose is Android's recommended modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs. | **Start migrating your UI to Jetpack Compose** Jetpack Compose allows interoperability with existing Views system. There are several strategies how to migrate parts of your UI to Compose and benefit from the perks Compose provides. Check our documentation on the [migration strategies](https://developer.android.com/develop/ui/compose/migrate), or alternatively check our [codelab](https://d.android.com/codelabs/jetpack-compose-migration) for a more hands-on project. |
| Compose 2022.10.00 - 2024.08.00 (1 points) | **Missing many new features and performance improvements!** By staying on an old version of Jetpack Compose, you're missing all the new features and improvements. Jetpack Compose was designed to be unbundled from the Android system to give developers the ability to decide when to upgrade. | **Upgrade to a newer version as soon as possible** Performance continutes to be our top priority and by upgrading you can see major performance improvements across the board. We are seeing \~20% improvement in scroll performance, 12% improvement to startup time, 22% performance improvement to text composables. More information on what improvements were added to the Jetpack Compose 2024.01.00 you can check in the [release blog post](https://android-developers.googleblog.com/2024/01/whats-new-in-jetpack-compose-january-24-release.html). |
| Compose 2024.01.00 - 2025.07.01 (2 points) | **Latest Jetpack Compose offers better performance and new features** By not adopting the latest Jetpack Compose versions, you're not getting all the bug fixes, performance improvements and new features that we're working on to help building your beautiful UIs. | **Upgrade to the newest version for additional performance improvements** By upgrading to the latest Compose version, we saw additional 17% performance improvement for time to first pixel in our benchmarks! In this version we also enabled by default the new [strong skipping mode](http://developer.android.com/develop/ui/compose/performance/stability/strongskipping), which allows radically reducing unnecessary compositions. In addition to that, we improved indication API to allow lazy creation of ripples, optimized the internal Compose representation to a more efficient data structure and started generating more efficient code. You can check more information on what was released in the [Compose 2024.09.00 blog post](https://android-developers.googleblog.com/2024/05/whats-new-in-jetpack-compose-at-io-24.html). |
| Compose 2025.08.00 or newer (5 points) | **Congratulations! This app is up to date with the latest stable Compose release.** Using the latest version of Compose is a great way to benefit from the performance improvements in each new version of Compose. | **Keep up the good work** Stay up to date with the latest stable Compose releases to continue benefitting from performance improvements and bug fixes. There is no immediate action to take in this area. |

Monitoring and optimization

### Report fully drawn state

Calling [`reportFullyDrawn()`](http://developer.android.com/reference/android/app/Activity#reportFullyDrawn()) by using the [`FullyDrawnReporter`](http://developer.android.com/reference/kotlin/androidx/activity/FullyDrawnReporter) or [`ReportDrawn()`](http://developer.android.com/reference/kotlin/androidx/activity/compose/package-summary#ReportDrawn()) lets the system know when the app is ready to be interacted with by a user. This enables access to the TTFD metric. This metric can be used for benchmarking and enables improved Startup Profile creation.  
Make an assessment Not using reportFullyDrawn() / FullyDrawnReporter (0 points) Using reportFullyDrawn() / FullyDrawnReporter (5 points)

| Evaluation | Recommendation |
|---|---|---|
| Not using reportFullyDrawn() / FullyDrawnReporter (0 points) | **Missing out on under the hood improvements and performance metrics.** Not reporting when the app is ready to be used is a missed opportunity to understand app startup time in more detail. Using this API allows the Android system to provide more detailed performance metrics and enables monitoring of Time to Fully Drawn. If your app is performing lazy loading and the initial display doesn't include all resources, such as when your app is fetching images from the network, you might want to delay calling [reportFullyDrawn()](http://developer.android.com/reference/kotlin/androidx/activity/FullyDrawnReporter) until after your app becomes usable so that you can include the list population as part of your benchmark timing. It's also important for the Android framework to know where a startup profile should stop being measured. | **Adopt reportFullyDrawn() / FullyDrawnReporter to unlock more detailed performance metrics.** Use the [FullyDrawnReporter](http://developer.android.com/reference/kotlin/androidx/activity/FullyDrawnReporter) API to report when the app is ready to be used. This will unlock more detailed performance metrics and enable monitoring of [Time to Fully Drawn](http://developer.android.com/topic/performance/vitals/launch-time#time-full). |
| Using reportFullyDrawn() / FullyDrawnReporter (5 points) | **Unlocked more detailed app startup performance metrics.** This app is using the [FullyDrawnReporter](http://developer.android.com/reference/kotlin/androidx/activity/FullyDrawnReporter) API to report when the app is ready to be used. This unlocks more detailed performance metrics and enables monitoring of [Time to Fully Drawn](http://developer.android.com/topic/performance/vitals/launch-time#time-full). | **Use information from TTFD to understand and improve app startup performance.** The Android Framework as well as the Google Play Console provide detailed performance metrics for [Time to Fully Drawn](http://developer.android.com/topic/performance/vitals/launch-time#time-full). Use these metrics to understand and improve your app's startup performance. When using the [macrobenchmarks](http://developer.android.com/topic/performance/benchmarking/macrobenchmark-overview) you can also inspect traces to see what exactly is happening during app startup. |

![](http://developer.android.com/static/images/picto-icons/layout.svg)  

## **0 out of 100 points**

Static App Performance Score

(0/7 questions answered)

## Tips for evaluating your app

Here are some tips when measuring your App Performance Score.

### Choose a representative device

When measuring your dynamic score, we recommend using the same type of device as
your user base. Unlike the static score, a dynamic score will vary based
on the device specs. If you don't know where to start, use a low-end device and
work on improvements from there.

### Assess dynamic score variability

It's possible that your dynamic score changes across multiple observation
periods, without you changing your code. This could be due to inherent
variability in the app performance or other system activities happening on your
device. If you notice that your score is highly variable, we recommend testing
multiple times in sequence and noting the most common behavior.

Your static score should remain stable unless you change your code.

### Use scores separately if needed

If you don't have the time or capacity to calculate both the dynamic and static
score, you can use each alone as well. Any improvement to your dynamic or static
score will still benefit your users.

### Supplement with other monitoring metrics

The App Performance Score is a quick, high-level way to assess app performance.
To get more detailed performance insights, consider exploring other data sources
such as [Android Vitals](https://play.google.com/console/about/vitals/),
[Firebase Performance Monitoring](https://firebase.google.com/docs/perf-mon),
and [benchmarks](https://developer.android.com/topic/performance/benchmarking/benchmarking-overview).

## How to improve your score

In general, if both your static and dynamic scores are subpar we recommend
taking actions to maximize your static score before troubleshooting the dynamic
one. Addressing shortcomings in the static score will likely improve the dynamic
score as well, so it's helpful to optimize the former as a first step to
improving your app performance. The static score is based on concrete values or
settings in your app code, whereas the dynamic metrics usually take longer to
investigate and identify the root cause of.

Within each segment, the App Performance Score provides actionable steps to
improve your app.

## Recommended for you

- Note: link text is displayed when JavaScript is off
- [Capture Macrobenchmark metrics](https://developer.android.com/topic/performance/benchmarking/macrobenchmark-metrics)
- [Get started with Baseline Profiles](https://developer.android.com/topic/performance/baselineprofiles/overview)
- [Create Startup Profiles](https://developer.android.com/topic/performance/baselineprofiles/dex-layout-optimizations)
- [Overview of measuring app performance](https://developer.android.com/topic/performance/measuring-performance)
- [Frozen frames](https://developer.android.com/topic/performance/vitals/frozen)