La segunda parte terminó con un chiste. El servidor que dibuja nuestro mapa como imágenes lee un mapa vectorial de la región perfectamente válido, y la única razón por la que existe es que nuestros móviles no eran capaces de dibujar ese mapa vectorial lo bastante rápido.
Dieciocho meses después, el chiste casi se ha acabado. Desde esta semana, un estilo por tema, servido por nuestra API, y un archivo de 58,67 MB dibujan el mapa en nuestra consola de administración y, en Android, en nuestra nueva app de socios. La app de Flutter que está hoy en las tiendas sigue mostrando imágenes, y lo seguirá haciendo hasta que la sustituyamos. Así es como hemos llegado hasta aquí, y por qué gana el vector.
Lo que cuestan las imágenes
Las imágenes funcionaban. Conviene decirlo lo primero: desde febrero de 2025, todos los mapas de la app salvo el satélite los dibujábamos nosotros, y nadie lo notó.
Lo que costaban era tiempo. En la segunda parte prometimos dibujar las teselas (tiles) de antemano, para que nadie esperara tres segundos por una calle que nadie había visto antes. Llegó en dos pasos. Al día siguiente del cambio añadimos un pequeño script que recorría el centro del pueblo en los zooms 17 y 18 y le pedía a nuestro propio servidor de teselas cada una de ellas, para que estuvieran dibujadas y guardadas antes de que nadie mirara. En abril de 2026 nuestro desarrollador de Flutter lo convirtió en un prerenderizado de verdad, con un grupo de renderizadores trabajando en paralelo, y un par de días después empezó a dibujar directamente de las teselas vectoriales a archivos.
Luego lo pusimos en marcha en serio. Los zooms del 13 al 19 sobre el rectángulo que cubría la cuadrícula de zoom hasta mayo suman 944.382 teselas por tema, y el 94 % son de los zooms 18 y 19. Nuestra VM de renderizado, la de la segunda parte, aguanta unos cuatro renderizados a la vez, de unos tres segundos cada uno. Eso son unos ocho días por tema. Así que el prerenderizado corre en mi Mac mini, donde un tema tarda de 10 a 12 horas y ocupa unos 15 GB. La VM ahora solo dibuja lo que falta.
La estimación del propio script decía unas siete horas. Contaba como progreso las teselas que se saltaba porque ya estaban en disco, y todos esos saltos llegaban de golpe al principio. Así que la estimación empeoraba cuanto más tiempo llevaba en marcha.
Esos 15 GB son solo la factura del almacenamiento. El precio real aparece cuando quieres cambiar algo. En abril oscurecimos los nombres de las carreteras y les pusimos un halo, porque costaba leerlos. En un mapa vectorial eso son unas pocas líneas en un archivo de estilo. Con imágenes significa volver a dibujar la pirámide entera, para los dos temas: un día de Mac mini y unos 30 GB que subir.
Y hay cosas que las imágenes sencillamente no pueden hacer:
- Las etiquetas vienen incrustadas. Cada nombre de calle forma parte de la imagen, en un solo idioma, así que quien tiene la app en ruso ve exactamente las mismas etiquetas que quien la tiene en inglés.
- Las etiquetas no se mantienen derechas. Gira el mapa y los nombres de las calles giran con él, boca abajo si sigues girando.
- Una región nueva es otra pirámide. La app está creciendo más allá de Torrevieja, y cada pueblo que añadimos supone renderizar y guardar sus imágenes, en cada tema.


Datos vectoriales antes que un renderizador vectorial
El primer archivo de nuestro propio Worker vectorial ni siquiera era un mapa. Eran nuestros puntos de interés.
En abril de 2025 montamos un segundo Worker de Cloudflare junto al servidor de teselas. Es una copia del Worker de Protomaps para PMTiles, un formato que mete una pirámide entera de teselas de mapa, vectoriales o ráster, en un solo archivo. El primer archivo que pusimos ahí fueron nuestros POI, cortados en teselas vectoriales con tippecanoe.
La app de Flutter ya no dibujaba teselas vectoriales, pero sí podía leerlas. Desde mediados de 2025, cada vez que llega una tesela de imagen, la app pide la tesela de POI del mismo sitio, la decodifica en Dart y dibuja cada punto como un marcador encima. Datos vectoriales, sin renderizador vectorial.
Los elementos puntuales son baratos, así que las teselas de POI llegan hasta el zoom 22. Y si un POI aparece o no en un zoom dado pasó a ser una propiedad del propio POI: un número en el archivo, sin imágenes que volver a dibujar. En mayo de 2026 tippecanoe se mudó a un Cloudflare Container que reconstruye el archivo cada noche. No puede vivir en el propio Worker: tippecanoe es un binario nativo, y un Worker no puede ejecutarlo.
Cómo funciona la parte vectorial
El mapa base también es un solo archivo PMTiles. Son los datos de OpenStreetMap de la región, cortados con tilemaker con el esquema de OpenMapTiles. Son los mismos datos que lee nuestro servidor de imágenes desde su primera tesela. Pesa 58,67 MB y vive en R2 detrás del mismo Worker que los POI.
El Worker nunca carga ese archivo. Lee la cabecera y el índice de nivel superior con una sola petición de 16 KB por un rango de bytes del archivo, y después pide cada tesela igual: un rango, solo los bytes de esa tesela. Lo único que guarda en memoria son hasta 25 bloques de índice ya parseados. Las teselas se cachean en el edge de Cloudflare durante un día. Así que la memoria del Worker no tiene nada que ver con el tamaño del archivo, y así es como Protomaps sirve el planeta entero desde un solo archivo. Para nosotros, una región más grande es un archivo más grande en el mismo bucket, no una arquitectura nueva. Cambiar el archivo es subirlo: cada lectura comprueba el ETag del archivo, así que el Worker se da cuenta solo de la nueva versión.
Encima de los datos va un estilo: un archivo JSON que dice qué dibujar, de qué color y en qué zoom. Adaptamos para móviles Positron de OpenMapTiles para el tema claro y Dark Matter para el oscuro:
- los nombres de los barrios se quedan en pantalla al acercarte, en lugar de desaparecer justo cuando los necesitas;
- todos los tamaños de texto crecen de forma suave con el zoom;
- cuando las etiquetas chocan, las ciudades ganan a los barrios, los barrios a las calles y las ciudades más grandes a las más pequeñas;
- los nombres de las calles van a lo largo de ellas;
- los caminos peatonales son una línea fina de puntos.
Cada estilo ocupa unos 22 KB. Eso es todo lo que cuesta un tema.
Esta semana esos estilos se mudaron a nuestra API, y los cambios para móviles de arriba salieron con la mudanza. Hasta ahora la consola, la app de socios y la reescritura de la app para usuarios llevaban cada una la misma copia antigua, así que cualquier cambio había que hacerlo a mano en todas. Ahora hay una sola versión mantenida, integrada en la API y servida por ella. Las apps guardan una copia empaquetada solo como semilla, para que un mapa pueda dibujarse antes de que responda la red. Un cambio incompatible recibe una ruta nueva, así que las compilaciones antiguas de la app nunca reciben un estilo que no sepan manejar.
Dos cosas que aprendimos por el camino:
- Las fuentes, de una en una. Un estilo puede listar fuentes de reserva, y MapLibre las pide todas en una sola petición, con los nombres unidos por comas. Nuestros glifos viven en R2, como archivos, y no hay ningún archivo con ese nombre combinado. Así que cada etiqueta de nuestros estilos usa exactamente un peso de una fuente, Metropolis.
- Al César lo que es del César. El archivo PMTiles no tenía atribución en sus metadatos, así que MapLibre atribuyó el mapa a la única parte que conocía: a sí mismo. El mapa decía «MapLibre Android» donde debería haber dicho «© OpenStreetMap contributors», y la licencia de OpenStreetMap exige lo segundo. El arreglo, también de esta semana, es una pequeña tabla en el Worker: el mapa base atribuye a OpenStreetMap, y nuestros propios POI a nadie. Arregló la atribución en todos los mapas que leen nuestras teselas vectoriales, en la consola y en Android, sin volver a subir un solo archivo.
En julio el mapa base también se mudó detrás del Worker de teselas. La dirección antigua ahora redirige allí, para lo que aún la tenga escrita en un estilo. El usuario más fiel de la dirección antigua es nuestro propio renderizador de imágenes: los estilos con los que dibuja siguen apuntando allí.
La consola fue primero
Nuestra consola de administración tuvo sus primeros mapas en mayo de 2026, y fueron MapLibre desde la primera línea. El motivo es un comentario al principio del primer componente de mapa:
«Dejamos mapbox-gl a propósito: maplibre es compatible en la API para todo lo que usamos, no necesita token de acceso, no llama a events.mapbox.com / map-sessions para telemetría y no pinta el logo de Mapbox.»
También tuvo algo que nuestro mapa de Flutter no tiene. Cada línea de autobús en la consola lleva unos pequeños chevrones que apuntan hacia donde va el autobús: MapLibre repite una imagen pequeña a lo largo de la línea mientras la dibuja y la gira en cada curva, así que siempre apuntan hacia delante. La versión de Flutter está escrita y sigue esperando.
Dos semanas después borramos nuestro antiguo editor de rutas, lo último del repositorio que usaba la librería web de Mapbox.
Queda una ironía. La consola tiene una pestaña que muestra la cuadrícula de zoom, el mapa de calor de la segunda parte que evita que la app de Flutter pida imágenes que nadie necesita, y deja previsualizar una nueva antes de publicarla. Esa pestaña dibuja la cuadrícula sobre un mapa vectorial.

Flutter, una vez más
Probamos el vector en Flutter dos veces. La primera, en noviembre de 2024, está en la segunda parte: funcionaba, y en Android daba tirones y se iba dibujando tesela a tesela.
El segundo intento terminó en marzo de 2026. El paquete vectorial de flutter_map tenía una nueva versión mayor en beta que renderiza con la API de GPU de Flutter en lugar del canvas normal, que es justo lo que necesita un mapa lleno de trazados. Nuestro desarrollador de Flutter la probó y, en un Redmi de gama media, la app se cayó:
MSAA is not currently supported on this backend.
[ERROR:flutter/impeller/renderer/backend/gles/buffer_bindings_gles.cc(409)] … Float uniform should have a float type.
[FATAL:flutter/impeller/renderer/backend/gles/render_pass_gles.cc(726)] Check failed: result. Must be able to encode GL commands without error.
Fatal signal 6 (SIGABRT) … (1.raster)
En pocas palabras: el renderizador de Flutter en Android tiene dos backends, uno moderno sobre Vulkan y otro más antiguo sobre OpenGL ES, y en algunos móviles elige el antiguo. Ese móvil era uno de ellos. El backend de OpenGL ES se encontró en los shaders del mapa un valor que no sabía pasar a la GPU. No lo trata como un fallo menor: no poder codificar un comando GL es fatal por diseño, así que el motor aborta la app entera. Y no prueba con Vulkan en su lugar.
Sin la vía de la GPU, con la beta anterior, todo funcionaba. Despacio. Esa versión vive en una rama que nunca se fusionó, y el cuelgue ni siquiera llegó a git: la rama es el plan B. En abril la app recibió un flutter_map más nuevo, todavía dibujando imágenes.
Las apps nuevas: tres motores de mapas tras una sola vista
En julio empezamos una app de socios para negocios, escrita en Swift y compilada para Android con Skip. Su primer mapa fue ráster, y no por gusto: el SwiftUI de Skip aún no tenía ni Map ni Canvas, así que el mapa son nuestras propias teselas de imagen colocadas como imágenes. El comentario que lo acompaña dice:
«Ráster en lugar de vector porque no necesita ningún motor de renderizado: una tesela es un PNG,
AsyncImagepuede cargarlo, y funciona igual en las dos plataformas sin ninguna dependencia nativa.»
Esa misma tarde tuvo MapKit en iOS, y a la mañana siguiente MapLibre en Android, dibujando el propio estilo vectorial de la consola. La parte de Android necesita algo de Kotlin, porque el gancho de Skip para vistas nativas de Android recibe una función de Compose, y esas no se pueden escribir en Swift. Todo lo que decide qué muestra el mapa se queda en Swift. Los tres están detrás de una sola vista:
«MapKit en iOS, MapLibre en Android, un mapa ráster de teselas como suelo bajo ambos. Los tres están detrás de
CuandoMapView, así que la elección es invisible por encima de esa línea, y un backend que falla cuesta un mapa más bonito y nada más.»
¿Por qué MapKit y no también MapLibre en iOS? Un solo renderizador significaría un solo conjunto de estilos. Pero también significaría renunciar al mapa de Apple y a todo lo que iOS hace con él. Nuestra regla para la reescritura de la app para usuarios, que está en marcha: «Un detalle de estilo novedoso nunca está por encima del propio mapa.»


Un mapa con un plan B debajo tiene una forma especial de fallar: en silencio. Nos topamos con tres en dos semanas.
- Un mapa en blanco que se estaba recargando. Swift reconstruye el objeto puente hacia Kotlin cada vez que la vista se vuelve a evaluar, así que un indicador de «¿ya he aplicado este estilo?» guardado en él siempre estaba recién creado. El mapa aplicaba su estilo unas dos veces por segundo, y aplicar un estilo tira todo lo cargado hasta ese momento. Así que nunca llegaba ninguna tesela. Parecía exactamente un servidor de teselas roto. El mismo mapa en blanco volvió dos veces más en la reescritura de la app para usuarios, por otras causas, y la nota que nos dejamos allí dice: «Un mapa que pinta su color de fondo y ninguna tesela es un mapa que está recargando su estilo.»
- Un mapa vectorial que en secreto era ráster. Cuando la reescritura de la app para usuarios tomó prestado el mapa de la app de socios, siguió buscando la clase de Kotlin con el nombre de paquete de la app de socios. La búsqueda fallaba, el fallo se tragaba, y Android dibujaba en silencio el suelo ráster. Hizo falta un día, y alguien usando la app de verdad, para darse cuenta: al arrastrar, el mapa se notaba «demasiado sensible», no giraba y el zoom iba a saltos. Eso es un mapa de imágenes. La app tiene una pantalla de desarrollador que dice qué motor dibujó el mapa, y llevaba todo ese tiempo diciendo «Raster tiles — fallback».
- Iconos que no dibujaban nada. Los estilos sacan sus iconos del sprite de OpenMapTiles, que aloja otra persona, y un icono que falta en él se dibuja como nada en absoluto. Ahora nuestros pines se dibujan en el dispositivo a partir de los trazados SVG de Maki.
Por qué gana el vector
Esta es la comparación para nuestra región, imágenes contra vector:
| Imágenes (ráster) | Vector | |
|---|---|---|
| Lo que producimos | 944.382 teselas PNG por tema, zooms del 13 al 19 | un archivo para todos los temas |
| Almacenamiento | unos 15 GB por tema | 58,67 MB en total, más unos 22 KB por tema |
| Cambiar el aspecto | 10–12 horas por tema en un Mac mini, y luego subirlo | editar un archivo JSON |
| Más allá de donde llegan los datos | cuatro veces más teselas por nivel de zoom | el móvil amplía lo que tiene |
| Servir una tesela | Worker, almacenamiento y, si falla la caché, un renderizado GL en una VM | Worker, caché en el edge, un rango de bytes del almacenamiento |
| Etiquetas | incrustadas, en un idioma, giran con el mapa | dibujadas en el móvil, siguen las calles, se mantienen derechas |
| Otro pueblo | otra pirámide, en cada tema | un archivo más grande en el mismo bucket |

Los números ni siquiera son el argumento principal. Con imágenes, cada decisión sobre el aspecto del mapa se paga en horas de renderizado, y cada región nueva en gigas. Con vector, las dos cosas se convierten en ediciones. Y ya no queda nada en un servidor que renderice nada.
Lo último de Mapbox
Dos pequeños finales, ambos en las dos últimas semanas.
El 4 de agosto por fin quitamos el CocoaPod MapboxMaps de la app de Flutter. Llegó con el SDK nativo el 20 de agosto de 2024, y el SDK en sí desapareció cinco días después. El pod se quedó casi dos años. Nada lo importaba, pero CocoaPods lo descarga de Mapbox, y esa descarga necesita un token secreto en ~/.netrc. Así que pod install fallaba en cada máquina a la que no se le hubiera dado uno.
El 11 de agosto el satélite salió del selector de mapas. Era el último estilo que aún venía de Mapbox. Quien ya lo tenía seleccionado lo conserva por ahora.
Lo que viene
- La app para usuarios con Skip. Cuando salga, Android dibujará nuestro mapa vectorial con MapLibre e iOS dibujará el de Apple. La pirámide de imágenes, el prerenderizado y la VM de renderizado podrán jubilarse junto con la app de Flutter.
- Etiquetas en tu idioma. Con vector, el idioma de las etiquetas es un ajuste del estilo, una expresión por capa de etiquetas, no un nuevo renderizado. Nuestros estilos todavía piden solo escritura latina, y es lo próximo que cambiaremos.
- Más región. Un archivo más grande en el mismo bucket.