Cómo optimizar código y recursos con R8 en tus apps Android

Última actualización: 18 de noviembre de 2026
  • R8 elimina el código y los recursos que nadie usa, reescribe el resto y acorta nombres para conseguir apps más pequeñas, con arranques más rápidos y menos fallos de respuesta.
  • Conviene activar la optimización en la compilación de lanzamiento y ajustar las reglas de conservación, que son el principal freno para que R8 pueda trabajar a fondo.
  • El Analizador de configuración de R8 mide cuánto código queda disponible para reducir, optimizar y ofuscar, y señala las reglas amplias, duplicadas o inútiles.
  • Completar la faena con App Bundles, imágenes ligeras, ajustes de idioma y densidad y una medición constante del tamaño marca la diferencia real en la descarga.

Desarrolladora de aplicaciones Android trabajando con documentación técnica en un MacBook en un entorno profesional.

Comprimir una app de Android no consiste solo en borrar archivos sueltos: es un ejercicio de equilibrismo entre tamaño, velocidad de arranque y memoria. El optimizador que Android lleva de serie, R8, hace buena parte de ese trabajo sin que tengas que escribir una línea extra: analiza qué código y qué recursos se utilizan de verdad, elimina lo que nadie invoca y reescribe lo que sobrevive para que se ejecute con menos sobrecarga. Lo que nota la persona que usa tu app es un inicio más ágil, menos memoria ocupada, una interfaz más fluida y menos mensajes de aplicación bloqueada.

La cuestión es dejarle margen para trabajar. Cuanto mayor sea la porción de tu base de código que R8 puede tocar, mejores serán los resultados. Las reglas de conservación demasiado amplias son el freno más habitual, porque blindan clases y métodos que a lo mejor nadie llama de forma dinámica, y con ellas se quedan también sus dependencias. Afinar esas reglas, medir y volver a probar es el bucle que separa una app simplemente publicada de una app realmente afinada.

Qué hace exactamente R8 y por qué deberías confiar en él

Pantalla de portátil mostrando código y herramientas de análisis de datos, representando el proceso de optimización con R8.

R8 funciona por fases encadenadas. Primero analiza tus puntos de entrada reales, como las actividades o los servicios declarados en el manifiesto, construye un mapa de todo lo que se referencia y descarta lo que queda fuera de ese mapa. Después entra en el terreno de las optimizaciones lógicas: sustituye llamadas por el cuerpo del método llamado, fusiona clases e interfaces, simplifica estructuras y recorta la sobrecarga de la ejecución. Para terminar, acorta los nombres de clases, campos y métodos, de manera que algo como com.example.MyActivity puede acabar llamándose a.b.a, con el ahorro de metadatos que eso supone.

  • Menos código muerto: las dependencias que solo usas en un pequeño porcentaje dejan de arrastrar todo su peso.
  • Ejecución más eficiente: la inserción de métodos y la fusión de clases reducen llamadas y presión sobre la memoria.
  • Archivos DEX más ligeros: la ofuscación ahorra metadatos y acelera la carga de clases.
  • Recursos ajustados: desde la versión 8.12 del complemento de Gradle, R8 también participa en la optimización de recursos.

Desde el punto de vista de quien usa la app, ese conjunto se traduce en arranque más rápido, menos consumo de memoria, mejor renderización y menos incidencias de tipo aplicación que no responde. La recomendación oficial es clara: activa la optimización en la compilación de lanzamiento. Para pruebas diarias o para el desarrollo de una biblioteca no suele compensar, porque el tiempo de compilación sube y depurar se complica cuando los nombres cambian.

Activar la optimización según la versión del complemento de Gradle

Si trabajas con versiones recientes del complemento de Android para Gradle, la cosa se ha simplificado bastante. Basta con activar una única marca dentro del bloque de optimización del tipo de compilación de lanzamiento y colocar tus reglas de conservación en un conjunto de código fuente específico, con archivos que terminen en .keep, por ejemplo dentro de src/main/keepRules. Ese modo nuevo abarca tanto código como recursos y trae incorporadas reglas por defecto para la plataforma que equivalen a las históricas de ProGuard con optimización, así que no hace falta declarar archivos adicionales.

En proyectos anclados a versiones anteriores del complemento, el camino clásico pasa por dos parámetros del tipo de compilación de release: uno que activa la minimización de código y otro que activa la reducción de recursos. Lo sensato es habilitar ambos a la vez y añadir el archivo de reglas optimizadas que genera el propio sistema, más tu fichero de reglas propio si lo necesitas. Mezclar compilaciones de release sin estos interruptores es una de las formas más silenciosas de regalar megas a tus usuarios.

Modo completo y reducción de recursos optimizada

El modo completo de R8 lleva años activo por defecto y aplica suposiciones más agresivas sobre el uso de reflexión y de llamadas dinámicas. Si en algún momento alguien dejó escrita la propiedad que lo desactiva, conviene borrarla: mantenerla apagada renuncia a buena parte del potencial del optimizador. Eso sí, el modo completo puede exigir reglas extra en proyectos con mucho código dinámico, así que pruébalo siempre con una compilación real de release y no solo con pruebas unitarias.

  Guía Completa sobre Spring Framework: Potenciando el Desarrollo Java

La reducción de recursos optimizada llegó con la versión 8.12 del complemento y, desde la 9.0, se aplica automáticamente cuando la reducción de recursos está activa. La idea es tratar los recursos como parte del grafo de código: antes, la herramienta de empaquetado generaba reglas de conservación que mantenían vivos recursos y código inaccesibles que se referenciaban entre sí; ahora, si una colección de código y recursos no se usa, no queda protegida por nada y desaparece. En apps con muchas variantes de factor de forma se han medido reducciones de tamaño muy por encima del cincuenta por ciento.

El Analizador de configuración de R8 y sus tres puntuaciones

Primer plano de un smartphone con una interfaz de aplicación minimalista, fluida y optimizada.

Este analizador es la herramienta que te dice si tu configuración está ayudando o estorbando. Genera estadísticas sobre qué porcentaje de tu base de código está realmente sujeto a reducción, a optimización y a ofuscación. Si la puntuación de reducción es del sesenta y seis por ciento, significa que R8 puede eliminar código en dos tercios de tu base; si el nivel de optimización está en ese mismo valor, solo puede aplicar inserción de métodos, fusión de clases y demás técnicas en dos tercios. La puntuación de ofuscación mide cuánto código puede pasar a nombres cortos para ahorrar metadatos.

Además de las métricas globales, el informe detalla el impacto de cada regla de conservación y las propiedades de optimización que bloquea. También identifica las reglas que provienen de bibliotecas de terceros, algo muy útil porque los autores de esas librerías no conocen tu implementación concreta y a veces escriben reglas tan generales que paralizan la optimización en partes de tu app que no tienen nada que ver con su funcionamiento.

Cómo generar el informe sin perder el tiempo

Para iterar rápido sobre tus reglas existe una tarea de Gradle específica que analiza la configuración de release sin llegar a empaquetar el APK ni el bundle. El ciclo de retroalimentación es mucho más corto y el informe HTML aparece en la carpeta de informes del módulo, dentro de un directorio dedicado a R8. Es la opción recomendada cuando estás ajustando reglas y quieres ver el efecto inmediato de cada cambio.

Si prefieres el análisis automático, cualquier compilación de release genera también un archivo HTML dentro de los resultados de mapeo. Puedes desactivar esa generación automática con la propiedad experimental correspondiente si te resulta molesta. En versiones antiguas del complemento, el truco pasa por añadir una versión reciente de R8 al classpath del proyecto y lanzar la compilación con una propiedad de sistema que indique el directorio donde volcar el informe.

Refinar reglas de conservación sin romper la app

El objetivo es conservar solo aquello a lo que se accede por reflexión de verdad, ni más ni menos. Empieza por las reglas que bloquean la optimización en una cantidad enorme de clases, revisa qué elementos protegen y comprueba si de verdad se invocan de forma dinámica. Después recorta el alcance: en lugar de conservar un paquete entero con todos sus miembros, limita la regla a clases y miembros concretos. Y antes de dar el cambio por bueno, ejecuta pruebas que cubran esas clases, campos y métodos afectados.

Ojo también con las reglas subsumidas. Si una regla protege todo un paquete y otra protege una clase dentro de ese paquete, la segunda no aporta nada y la primera está bloqueando optimizaciones que quizá no necesitas. Decide cuál de las dos es exacta: si la estrecha está bien escrita, elimina la amplia y desbloquea el resto del paquete; si es la amplia la que apunta bien, bórrala igualmente pero reescríbela para que afecte solo a lo imprescindible. Después vuelve a pasar el analizador y compila un release completo para verificar que todo sigue en pie.

Reglas duplicadas, sin uso y de bibliotecas

El analizador señala dos fuentes claras de desorden: reglas que no coinciden con ninguna clase, método o campo de la compilación actual, y reglas idénticas repetidas en el mismo archivo o en archivos distintos. Las primeras suelen quedar como basura después de refactorizar o de quitar dependencias; las segundas complican el mantenimiento sin aportar nada. Limpiarlas hace que la configuración sea más fácil de leer y de depurar.

Con las bibliotecas de terceros hay poco margen, porque sus reglas vienen empaquetadas y no puedes editarlas selectivamente. Lo práctico es documentar el impacto con el informe y avisar al mantenedor, o bien replicar temporalmente esas reglas en tu proyecto, excluir las más amplias y medir la ganancia potencial antes de decidir si merece la pena asumir el riesgo.

  Programación modular: qué es y por qué deberías dominarla

ProGuard y R8: parecidos, pero no gemelos

ProGuard hizo durante años cuatro cosas: eliminaba elementos no usados, optimizaba el bytecode, ofuscaba nombres y añadía información de preverificación. R8 recoge ese testigo y aprieta más: inserta métodos con más agresividad, fusiona clases, convierte enumeraciones en enteros cuando puede y entiende mejor las características de Kotlin. Además compila más rápido y, con la desazucarización de la biblioteca principal, permite usar APIs modernas de Java en versiones antiguas de Android.

En cuanto a las reglas, R8 acepta las de ProGuard y añade algún modificador propio, como el que fuerza la inserción de un método concreto o el que la impide. La conversión de nombres no cambia el comportamiento, pero sí complica la lectura de los rastros de pila: conserva siempre el archivo de mapeo de cada release para poder recuperar la traza original cuando llegue un fallo de producción.

Errores típicos al minificar y cómo salir del atolladero

Los tropiezos se repiten: class not found por una clase eliminada, no such method por un método renombrado, modelos que no se serializan porque han perdido sus nombres, o bibliotecas que asumen que nada va a cambiar. Casi siempre el diagnóstico pasa por revisar qué se accede por reflexión y añadir la regla mínima necesaria. Para investigar, activa la impresión de uso, de semillas y de mapeo en un archivo temporal, o desactiva optimizaciones concretas de forma puntual para aislar la culpable.

También conviene tener presente que herramientas externas que regeneran o parchean archivos DEX pueden romper las optimizaciones que R8 ha preparado con cuidado. Si tu cadena de compilación tiene un paso de ese estilo, revísalo antes de culpar al optimizador. Y si el rendimiento de compilación te preocupa, existen ajustes para adaptar R8 a tu entorno sin renunciar a los beneficios.

Reducir recursos: imágenes, densidades e idiomas

Los recursos suelen ser una porción enorme del paquete. Convertir los mapas de bits a WebP reduce peso manteniendo calidad, y los drawables vectoriales evitan duplicar el mismo icono para cada densidad. Configurar solo los buckets de densidad que realmente usas y limitar los idiomas incluidos recorta bastante, sobre todo en apps con muchas traducciones. Para los PNG que no puedas convertir, existen utilidades de compresión sin pérdida apreciable.

También ayuda teñir programáticamente un único recurso en escala de grises en lugar de empaquetar varias versiones coloreadas, cargar bajo demanda las imágenes grandes que no hacen falta al arrancar y eliminar recursos huérfanos con la inspección de código del IDE. Si un recurso se referencia solo desde código muerto, la reducción optimizada lo detecta y lo quita, cosa que antes no ocurría porque los dos procesos iban por separado.

Layouts, estilos y jerarquías de vistas

Aplanar jerarquías no reduce el APK, pero sí mejora el rendimiento, que es la otra mitad del objetivo. Sustituye anidamientos innecesarios de contenedores por un ConstraintLayout bien planteado, extrae componentes comunes con include y define estilos para no repetir atributos. El inspector de diseño te ayuda a detectar árboles de vistas absurdamente profundos que ralentizan la inflación.

App Bundles, módulos dinámicos y bibliotecas nativas

Publicar en formato de bundle cambia las reglas del juego: la tienda genera paquetes ajustados a cada dispositivo, de modo que cada usuario descarga solo el código y los recursos que le corresponden. Las descargas bajan de forma notable respecto a un APK universal, porque se filtran idiomas, densidades y arquitecturas que no aplican. Además se pueden repartir funcionalidades en módulos de característica que se descargan bajo demanda, con criterios condicionales o instantáneos.

En cuanto a las bibliotecas nativas, incluir solo las arquitecturas que soportas y mantener la compresión activada evita arrastrar binarios que nadie va a ejecutar. Si compilas con Bazel en lugar de Gradle, también puedes integrar R8 en la tubería, aunque conviene recordar que ese soporte no es oficial para el desarrollo de apps Android.

Medir el tamaño y vigilar la evolución

Dashboard de analíticas de rendimiento en un ordenador portátil, ilustrando la medición de recursos y tamaño de la app.

Sin medición no hay optimización. El analizador de APK del IDE te enseña qué pesa de verdad dentro del paquete, y una tarea personalizada de Gradle puede informar del tamaño después de cada compilación. Añadir esa comprobación a la integración continua convierte el control del tamaño en algo automático y evita que un par de dependencias nuevas inflen el binario sin que nadie se dé cuenta.

Cómo ha cambiado el comportamiento entre versiones

Merece la pena repasar la evolución reciente porque explica muchas configuraciones heredadas que ya no tienen sentido. La versión 8.0 activó el modo completo por defecto; la 8.6 mejoró el retrazado incluyendo archivo y línea para cualquier minSdk; la 8.12 estrenó la reducción optimizada de recursos y el retrazado automático en Logcat; la 9.0 la activó por defecto, filtró opciones globales en reglas de consumidor y optimizó las comprobaciones de nulos de Kotlin; la 9.1 reempaquetó clases por defecto; y la 9.3 estrenó el bloque de optimización simplificado y el conjunto de reglas con extensión .keep.

  Guía Completa sobre LEGO Education SPIKE Prime

Con todo esto sobre la mesa, lo que de verdad mueve la aguja es una rutina sencilla: activar la optimización en release, revisar el informe del analizador cada cierto tiempo, recortar reglas que sobran, limpiar recursos e imágenes, distribuir con bundles y medir el tamaño en cada entrega. Son pasos pequeños que, sumados, convierten una app pesada y lenta en una app que se descarga en un suspiro y arranca al instante. Y como el código y las dependencias no dejan de crecer, la revisión tiene que ser continua: lo que hoy está afinado se desafina en cuanto entra una librería nueva o se añade una funcionalidad con sus propios recursos.

TecnoDigital

TecnoDigital

Apasionado por la tecnología y el desarrollo de software, me adentro en el universo de sistemas e informática con el objetivo de fomentar la innovación y resolver desafíos complejos.

Preguntas frecuentes

¿Qué hace exactamente R8 con el código de mi aplicación?

Analiza los puntos de entrada declarados, construye un mapa de referencias y elimina todo aquello que no se alcanza desde ellos. Después reescribe el código que queda para ejecutarse con menos sobrecarga y acorta los nombres de clases, campos y métodos para ahorrar espacio.

¿Cómo se activa la optimización de R8 en las versiones más recientes del complemento de Gradle?

Se activa con una marca dentro del bloque de optimización del tipo de compilación de lanzamiento, que cubre tanto código como recursos. Tus reglas propias van en un conjunto de código fuente específico, en archivos con extensión .keep.

¿Qué diferencia hay entre reducir código y reducir recursos?

La reducción de código elimina clases, campos y métodos inalcanzables, mientras que la reducción de recursos quita imágenes, layouts y demás archivos que no se usan. En las versiones modernas ambas tareas se integran en un mismo grafo de referencias, lo que evita conservar recursos enlazados solo desde código muerto.

¿Para qué sirve el Analizador de configuración de R8?

Mide el porcentaje de tu base de código que queda disponible para reducir, optimizar y ofuscar, y desglosa el impacto de cada regla de conservación. Con esos datos puedes localizar las reglas demasiado amplias, las duplicadas y las que ya no coinciden con nada.

¿Por qué una regla de conservación amplia perjudica el rendimiento de mi app?

Porque impide que R8 toque no solo lo que esa regla protege, sino también todo lo que depende de ello. El resultado es más código en el paquete, más metadatos y menos margen para aplicar inserción de métodos o fusión de clases.

¿Conviene publicar con App Bundles en lugar de un APK universal?

Sí, porque la tienda genera paquetes adaptados a cada dispositivo y cada usuario descarga solo los recursos de idioma, densidad y arquitectura que necesita. Ese ajuste reduce de forma notable el tamaño de la descarga sin que tengas que mantener artefactos distintos.

¿Cómo puedo leer un rastro de pila de una compilación ofuscada?

Necesitas el archivo de mapeo que se genera junto a cada compilación de lanzamiento y aplicar la herramienta de retrazado de R8. Las versiones recientes incluso vuelven a trazar automáticamente las trazas en la ventana de Logcat del IDE.

¿Merece la pena optimizar también una biblioteca que voy a publicar?

La optimización completa rinde mejor cuando R8 ve todo el grafo de la aplicación, así que el grueso del trabajo se hace al compilar la app final. Aun así, una biblioteca puede preparar sus reglas de consumidor con cuidado para no bloquear optimizaciones en los proyectos que la integren.