Desde esta semana, los mapas claro y oscuro de Cuando son nuestros. Los datos son de OpenStreetMap; las imágenes las dibuja nuestro propio servidor, con nuestros propios estilos, y se guardan en Cloudflare. El satélite sigue viniendo de Mapbox. Si usas la app y no has notado nada, esa era la idea.
Esta es la historia de cómo llegamos aquí. Mirando atrás estos últimos seis meses, cada decisión que tomamos sobre el mapa salió de una sola cosa: de cómo se cobraba el mapa.
Cinco días de lo auténtico
El primerísimo mapa, en agosto, fue el SDK de Flutter de la propia Mapbox. Nativo, vectorial, fluido: la forma correcta de meter un mapa en una app.
Duró cinco días. Los motivos fueron aburridos. El plugin no funcionaba en la compilación web, donde los navegadores de escritorio recibían un educado «todavía no es compatible con el plugin de mapas», y nosotros queremos una sola base de código para Android, iOS y la web. Además, la compilación de Android necesitaba un token de descarga especial de Mapbox, y el nuestro era del tipo equivocado.
Así que nos pasamos a flutter_map, que funciona en todas partes porque hace algo muy simple: coloca en una cuadrícula imágenes cuadradas del mapa, llamadas teselas (tiles), y va pidiendo otras nuevas a medida que desplazas el mapa y haces zoom. Las imágenes venían de Mapbox: su estilo Navigation Day para el modo claro, Navigation Night para el oscuro, y además Streets y Satellite.
La aritmética
Dos semanas después echamos las cuentas y las pusimos por escrito en un issue que proponía volver al SDK. Mapbox cobra las dos cosas de formas completamente distintas:
- El SDK móvil se cobra por usuario activo mensual, y los primeros 25.000 al mes son gratis.
- Static Tiles, las imágenes que mostraba flutter_map, se cobran por petición, y las primeras 200.000 peticiones al mes son gratis.
Parecen muchas peticiones hasta que las cuentas: cada desplazamiento y cada zoom piden una pantalla nueva de teselas. En palabras del propio issue: «nos quedaríamos sin las 200k peticiones al mes de Static Tiles antes de tener siquiera usuarios».
Y aun así pecaba de optimista. Los tres agotamos la cuota mensual gratuita sin esfuerzo, solo probando, y desde entonces hasta esta semana le pagamos a Mapbox entre 10 y 30 $ al mes por una app que apenas tenía usuarios. Con el SDK, tres personas no habrían costado nada. Pero acabábamos de dejar el SDK por buenos motivos. Hacer las teselas el doble de grandes (512 píxeles en lugar de 256), para que una pantalla necesite la cuarta parte, alivió el golpe. La solución de verdad era dejar de pagar por tesela.
La semana en que probamos lo vectorial
La solución obvia son las teselas vectoriales. En lugar de imágenes, el servidor manda el mapa como datos, carreteras, edificios y etiquetas, y el móvil lo dibuja. Las teselas son minúsculas, cambiar el estilo es editar un JSON y las etiquetas siguen derechas cuando giras el mapa.
En noviembre lo probamos con el módulo de teselas vectoriales de flutter_map, solo en móvil (la web se quedó con imágenes). Técnicamente funcionaba en las dos plataformas. En un iPhone iba bien. En Android el mapa iba con retraso y a tirones, y se le veía dibujarse tesela a tesela.
Una app de autobuses se abre en una parada, con el móvil que tengas, y muchos de esos móviles son Android de gama media. Una semana después, lo vectorial había desaparecido.
No dibujes lo que nadie mira
Así que imágenes. Las imágenes tienen una propiedad desagradable: cada nivel de zoom tiene cuatro veces más teselas que el anterior. El nivel de calle que quiere casi todo el mundo, en torno al zoom 18 o 19, es donde están casi todas las teselas.
Pero la mayor parte de nuestra región es monte bajo, campos de cultivo, dos lagunas saladas (una de ellas rosa) y el mar. Nadie necesita ver una laguna salada a zoom 19. Y nadie debería poder pedirla: cada tesela que se puede pedir es una tesela que alguien tiene que descargar, pagar o dibujar.
Así que el 12 de febrero el servidor empezó a calcular una cuadrícula de zoom. Es una cuadrícula gruesa colocada sobre la región, y cada celda guarda un solo número: hasta dónde se te permite hacer zoom ahí. Las reglas son sencillas:
- Todo empieza en zoom 13, que basta para ver dónde están los pueblos.
- Una celda con una parada a un par de kilómetros de su centro llega hasta 22, y sus vecinas reciben 16.
- Una celda por la que pasa una línea de autobús recibe 16, y sus vecinas alrededor de 15.
- Siempre gana el valor más alto. A una celda nunca se le baja.
La cuadrícula llega a la app como un pequeño archivo protobuf. La app mira dónde está el centro de la pantalla y limita el zoom ahí, interpolando entre celdas vecinas para que el límite se deslice en vez de saltar. Además, ya no se puede desplazar el mapa fuera de la región.

Son 54 × 72 celdas de unos 800 metros sobre unos 2.560 km², y solo 452 de sus 3.888 celdas permiten pasar del zoom 13. Si cuentas las teselas entre el zoom 13 y el 19 cuyo centro cae donde la cuadrícula permite ese zoom, salen unas 40.000 de 949.000: más o menos un 4 %, o 24 veces menos que la pirámide completa.
Casi todo el tiempo se fue en ajustarla: hasta qué distancia alrededor de una parada debería poderse hacer zoom hasta el final, qué anchura debería tener el corredor de una línea y dónde está el «suficiente» para un pueblo por el que solo pasas.
Tener esta cuadrícula es lo que hizo pensable el siguiente paso.
Dibujar el nuestro
El 14 de febrero empezamos un servidor de mapas propio. La primera tarde había dos enfoques uno al lado del otro:
- el kit estándar: tilemaker para cortar los datos de OpenStreetMap en teselas vectoriales y tileserver-gl para servirlas y renderizar imágenes a partir de ellas;
- un script de cuarenta líneas que renderizaba una sola tesela con MapLibre Native directamente. De todos modos, tileserver-gl renderiza con MapLibre Native por debajo.
tilemaker se quedó para los datos. El script ganó la otra mitad. Tres días después era un pequeño servidor Express, y al final de la semana su núcleo era así, algo recortado:
app.get('/tiles/:style/:size/:z/:x/:y', async (req, res) => {
// …parse z, x, y and the size…
const center = mercator.ll([(x + 0.5) * 256, (y + 0.5) * 256], z)
const map = new maplibre.Map({ ratio: 1.0 })
map.load(styles[req.params.style])
map.render({ zoom: z, center, width: size, height: size }, (err, rgba) => {
map.release()
const png = new PNG({ width: size, height: size })
png.data.set(rgba)
res.set('Content-Type', 'image/png')
png.pack().pipe(res)
})
})
Cada petición crea un mapa nuevo, apunta una ventana de 512 píxeles al centro de la tesela que pediste, la renderiza y devuelve un PNG. MapLibre Native es el mismo renderizador en C++ que llevan dentro los SDK móviles de MapLibre, y necesita un contexto OpenGL. Un servidor no tiene pantalla, así que todo corre bajo Xvfb, una pantalla virtual, dentro de un contenedor.
Los estilos están adaptados de Positron de OpenMapTiles para el claro y de Dark Matter para el oscuro. Por el camino probamos algunos más (OSM Bright, Liberty, uno de montaña, uno nocturno) y nos quedamos con Positron y Dark Matter, que están pensados para quedarse discretamente debajo de lo que dibujes encima.
Y aquí viene lo gracioso. La entrada del renderizador es un mapa vectorial de la región que nuestra propia API ya sirve: OpenStreetMap, cortado en teselas vectoriales por tilemaker. O sea, tenemos un mapa vectorial perfectamente bueno y un servidor que lo convierte en imágenes, porque los móviles no lo dibujan lo bastante rápido. Ya lo sé.
Delante del renderizador hay un Cloudflare Worker, y es lo único que puede llegar al renderizador. Para cada tesela mira primero en R2, el almacenamiento de objetos de Cloudflare. Si no está, se la pide al renderizador, devuelve el PNG al móvil y de paso guarda una copia en R2. Así que cada tesela se dibuja exactamente una vez, para quien la mire primero.
Eso importa, porque dibujar es lento. La máquina en la que corre tarda unos tres segundos en renderizar una tesela y puede con unas cuatro a la vez. La primera persona que hace zoom en una calle nueva espera, y todas las que vienen detrás no. Con un millón de teselas posibles, sería una espera larguísima. Con cuarenta mil, no pasa nada.

El cambio
En la app, el cambio fue casi aburrido. A propósito: nuestras URL de teselas tienen la misma forma que las de Mapbox, /{style}/512/{z}/{x}/{y}@2x, así que para flutter_map el mapa nuevo es otra plantilla de URL y otro token de acceso.
Ahora cada estilo sabe quién lo proporciona. El claro y el oscuro son nuestros. El satélite se queda con Mapbox, porque no tenemos de dónde dibujarlo. Streets ha desaparecido. Y el logo de Mapbox solo aparece cuando estás mirando teselas de Mapbox. Nuestro desarrollador de Flutter subió lo último poco antes de las dos de la madrugada, que según me dicen es la hora tradicional.
Lo que cuesta
- Dinero: Mapbox, solo para el satélite. El almacenamiento de R2 y las peticiones al Worker se quedan en calderilla. El renderizador corre en una VM pequeña que ya teníamos.
- Tiempo: tres segundos para la primera persona que ve una tesela que nadie ha visto antes.
- Cambiar el aspecto: este es el precio de verdad. Una imagen lleva el estilo incrustado. Cambiar un color significa tirar todas las teselas que tenemos guardadas y volver a dibujarlas todas, y eso dos veces, porque hay dos temas.
Lo siguiente
- Dibujar por adelantado, para que nadie espere los tres segundos. La cuadrícula de zoom nos dice exactamente qué teselas dibujar.
- Registrar qué teselas pide la gente de verdad, y si salieron del almacenamiento o hubo que dibujarlas. Eso entra mañana.
- Lo vectorial, algún día. El mapa ya es vectorial en el servidor. Son los móviles los que hay que convencer.
- El momento salió bien. Para cuando empezamos a hablarle de Cuando a la gente en serio, todos los mapas que tenía, salvo el satélite, eran nuestros.
- Las imágenes siguen ahí. La app de Flutter dibuja nuestras teselas ráster hasta hoy, y la cuadrícula de zoom sigue viajando con ella. Ahora la genera la API, sobre un área más grande, y tiene una pestaña propia en nuestra consola de administración solo para ajustarla.
- Dibujar por adelantado llegó en abril de 2026. Del zoom 13 al 19 sobre el recuadro de la cuadrícula son 944.382 teselas por tema. La VM necesitaría unos ocho días por tema, así que el prerenderizado corre en mi Mac mini: de 10 a 12 horas por tema, unos 15 GB cada uno. La VM solo dibuja lo que falta.
- Lo vectorial ganó de todos modos, solo que no en Flutter. Toda la región como un único archivo vectorial (un archivo PMTiles) ocupa 58,67 MB. Eso es unas 255 veces menos que un solo tema ráster, y sirve todos los temas a la vez: un tema nuevo es un archivo de estilo de 22 KB. Un Worker lo sirve directamente desde R2, leyendo solo los bytes que necesita cada tesela, sin máquina de renderizado. Más allá del zoom más profundo del archivo, el móvil simplemente amplía los datos vectoriales, así que un mapa vectorial tampoco necesita la cuadrícula de zoom.
- Dónde se usa: nuestra consola de administración pasó a MapLibre en mayo de 2026. Las apps nuevas, reescritas en Swift con Skip, dibujan mapas vectoriales: MapLibre sobre nuestras teselas en Android y MapKit de Apple en iOS.
- Flutter tuvo un intento vectorial más en 2026, con el renderizado por GPU activado. Se cerró de golpe en un Redmi de gama media. Esa es la historia del segundo post sobre mapas.
- El límite de zoom nunca se deslizó. La app convierte la posición en números enteros de celda antes de «interpolar» entre ellos, así que siempre lee exactamente una celda y, al final, el límite salta. Nadie se dio cuenta en año y medio.
- El satélite, lo último que tomábamos de Mapbox, salió del selector de mapas en agosto de 2026.