En la segunda mitad de 2025, varios equipos que habían llevado juegos casuales a las super-apps comenzaron a auditar una métrica pasada por alto: el tiempo desde el primer toque del usuario hasta el primer frame pintado. La razón por la que de repente importó es que el dinero se movió. Los mini-games de WeChat ingresaron 53.500 millones de RMB en 2025 con más de 500 millones de jugadores mensuales; las Telegram Mini Apps cruzaron mil millones de dólares en volumen anual de transacciones con más de 450 millones de usuarios mensuales; los usuarios activos mensuales de Discord alcanzaron 260 millones. Toda la apuesta descansa sobre "toca y juega": un usuario toca y la cosa debe aparecer en pantalla de inmediato. Cuando un mini-program muestra una pantalla blanca de dos segundos en la primera apertura, la mayoría ya se ha deslizado para salir. Para un observador, esto no es un problema de "afinar el rendimiento"; es la entrada a la mesa.
Los dos segundos, desglosados, son tres impuestos
La pantalla blanca no es un fallo mágico; son tres costos pagados en secuencia, y cada uno es más caro en la primera apertura. El primero es la asignación del motor: el runtime debe entregar a este mini-program su propia instancia del motor JS, construir un heap e inicializarlo. El segundo es el parseo y la compilación: unos pocos cientos de KB de JS deben parsearse y compilarse a bytecode. El tercero, y el más desagradable, es el calentamiento del puente: antes de que la lógica del mini-program y la capa nativa se llamen por primera vez, ambos lados del puente deben estrechar la mano y construir un canal, y cualquier llamada anterior a eso es bloqueante.
Lo que hace que "la primera apertura" sea irremediable son los niveles de caché de código de V8. V8 almacena en caché la salida compilada en tres niveles: frío (no almacena nada, recompila cada vez), tibio (almacena el nivel superior del script pero no las cachés en línea ni las clases ocultas) y caliente (almacena también el resultado de la compilación optimizada). La trampa es que el nivel asciende según cuántas veces se ha accedido a un script en ese origen. La primera apertura siempre cae en frío: el motor compila desde cero, y la apertura que decide si el usuario se queda es exactamente la más fría a nivel global. El "arranque instantáneo" que un desarrollador mide localmente es en realidad la segunda o tercera apertura, porque las aperturas locales repetidas ya empujaron la caché a caliente.
Más insidioso es el nivel JIT. En dispositivos de gama media y alta, V8 ejecuta el compilador optimizador completo; en dispositivos con memoria escasa, el runtime puede bajar a modo lite y omitir JIT por completo, ejecutando todo a través del intérprete. Eso significa que el mismo código no solo arranca más lento en frío en un teléfono de gama baja, sino que corre a una velocidad de estado estable completamente distinta. Tratar el número del escritorio como el número del usuario es el error de juicio más común en este tipo de auditoría.
Cada host maneja el arranque en frío de forma distinta
Si se aleja la lente hacia el host, WeChat, Telegram y Discord tratan el arranque en frío de manera muy diferente, lo que también decide la palanca que un desarrollador tiene realmente. WeChat aproxima el "pre-descarga más subpaquetes": el paquete del mini-program es programado por la plataforma en cierto sentido, y lo que el desarrollador controla es principalmente el tamaño del paquete principal. La Mini App de Telegram es esencialmente una página web corriendo en un WebView nativo, por lo que el arranque en frío se acerca a un primer pintado web, con la instancia del motor y el WebView gestionados por el sistema. Las Activities de Discord mueven el renderizado a una mezcla de streaming en la nube y WebView local, y la primera entrada suele cruzar un saludo de conexión.
Para los desarrolladores de terceros la conclusión es consistente: ninguna de las tres —asignación del motor, parseo o calentamiento del puente— está realmente a su alcance. Lo único que un desarrollador puede verificar repetidamente es cuánto trabajo hace realmente la primera apertura. Apostar por "el host optimizará por mí" tiende a producir diferencias inexplicables e irreproducibles en el campo.
Precargar en caliente: funciona en la oficina, falla en el terreno
El instinto cuando la primera apertura es lenta es precargar: arrancar el runtime y prefetch la primera ruta antes de que el usuario toque. Esto funciona de maravilla en los teléfonos de prueba del equipo, porque son los buques insignia del año pasado con memoria de sobra; el SO nunca toca la instancia precargada.
Tras el lanzamiento, el cuadro se invierte. En 2025, aproximadamente el 89 % de los smartphones vendidos en el sudeste asiático costaban menos de 200 dólares, y en Vietnam esa cuota fue del 51 %; son dispositivos con 2–4 GB de RAM y un motor WebView dos versiones mayores por detrás. La memoria tomada en préstamo para la precarga es reclamada en los términos del SO —no es negociable, el Low Memory Killer simplemente la corta—. La corta precisamente cuando la tarjeta precargada está a punto de mostrarse, convirtiendo una pantalla blanca en una negra o en un ANR directo. Un caso real: un equipo de juegos casuales habilitó la precarga al lanzar, las tasas de caída en gama baja subieron, y solo bajaron tras desactivarla. La precarga en caliente es un extra en dispositivos con memoria de sobra y un pasivo en los que no la tienen —y en 2025 estos últimos son la mayoría de los usuarios.
La única palanca dura: reducir la primera pantalla
El motor pertenece al runtime, la precarga no puede confiarse, y la estrategia del host no puede cambiarse. La única palanca que un desarrollador puede verificar repetidamente es dejar de hacer tanto en la primera apertura. Concretamente: mantener el JS de la primera pantalla bajo un presupuesto (muchos equipos usan ~200 KB como límite), cargar de forma perezosa todo lo que pueda esperar y renderizar solo el viewport en el primer pintado. Esto no es un truco ingenioso; es disciplina. Cada dependencia síncrona extra de la primera pantalla es otro impuesto al primer arranque del usuario.
| Etapa | Primera apertura | Desde la segunda | Control del desarrollador |
|---|---|---|---|
| Asignación del motor | Precio completo | Ya existe | Ninguno |
| Parseo y compilación | Nivel frío, recompila | Nivel caliente, caché | Indirecto (escribir menos, subpaquetes) |
| Calentamiento de puente | Saludo bloqueante | Canal construido | Ninguno |
| Nivel JIT | Puede bajar a lite | Puede subir | Ninguno, pero reducir carga |
| Carga de primera pantalla | Criterio del desarrollador | Criterio del desarrollador | Sí, y la más pesada |
Para medir el número real no basta con el entorno local. Una práctica recomendada consiste en tomar un Android de gama baja real, borrar toda la caché del runtime y arrancar en frío desde onLaunch hasta el primer frame. Una base repetidamente validada es un dispositivo de 3 GB de RAM, Android 11, WebView 94 —cualquier número de gama más alta solo sirve para consolar al equipo—. Un equipo redujo el JS de primera pantalla de 800 KB a 180 KB, bajando el primer arranque de 2,1 s a 0,9 s y elevando la retención al día siguiente unos pocos puntos; la ganancia no vino de un arte oscuro sino de "en el primer arranque genuinamente tenía poco que hacer".
La conclusión
La pantalla blanca del primer arranque no es un bug; es la primera frase del mini-program al usuario. Esa frase tiene una oportunidad, y los niveles de caché de V8, el cambio de nivel JIT y la reclamación de memoria del SO no darán una segunda. El framework y el runtime pertenecen a otro; el tamaño de la primera pantalla pertenece al desarrollador. Reducirlo primero, y luego considerar otras optimizaciones, es el orden que mantiene la disciplina.
Fuentes
- web.dev — Ruta de renderizado crítica y presupuestos de rendimiento
- V8 — Almacenamiento en caché de código
- V8 — Lanzamiento de V8 (caché de bytecode)
- Android Developers — WebView y memoria de gama baja
- Telegram Mini Apps — descripción de la plataforma
- Discord — documentación para desarrolladores de Activities