OpenMapTiles: Vector Tiles from OpenStreetMap

After months of work, we are thrilled to announce a new game-changing open-source project!

OpenMapTiles (http://openmaptiles.org) provides the fastest way how to setup custom styled world maps with open-source software. In a few minutes, you can have your own OpenStreetMap tile server - ready for use in your websites or products.

Just download the pre-generated vector tiles and get started

The project turns the publicly available OpenStreetMap data into ready-to-use packages containing vector tiles for the whole planet, individual countries and major cities.

Downloaded map tiles can be displayed on websites with JavaScript viewers, used in native mobile applications on Android and iOS (even offline), or turned into traditional raster tiles or high-resolution images for printing.

There are online guides to get started.

Open Map Styles & Open Tile Schema

We have prepared a set of beautiful Open Map Styles for our vector tiles. The styles are free and open-source, and you can adapt the design and code for your project or commercial product however you like. Either use one of our map styles directly as your base map or as a starting point for your own map design. You can also use an open-source visual map style editor.

Open Map Styles compatible with OpenMapTiles Vector Tiles
Our new Vector Tile Schema is encoding the cartography decisions made on top of OpenStreetMap, Natural Earth and other OpenData sources and is 100% open and free to use, extend or build upon. We hope people will adapt, copy and reimplement our schema and data model in their projects while providing attribution.

Open-source tools and no vendor lock-in

The whole project is open-source, documented and comes with a license which is friendly even for business use (BSD + CC-BY). The project reuses existing many open-source components, map designs and open standards from the OSM & FOSS community and Mapbox Inc. The work on the new open vector tile schema was done in cooperation with Paul Norman and Wikimedia Foundation and was initially modelled after the cartography of the Positron base map from Carto (former CartoDB), with their permission.

With OpenMapTiles there is no lock-in to a single hosting platform or provider, and interested parties can adopt our workflow and do the tile generating as well as hosting completely independently and in-house. We offer a set of services and preprocessed data - including worldwide contour lines and hill shading datasets - to speed up the adoption of the project and applications in production use.

The OpenMapTiles project is a successor of OSM2VectorTiles, a project which won the OpenStreetMap Innovation Award of 2016 at SOtM in Brussels and which started in Switzerland as a student bachelor thesis at HSR Rapperswil in cooperation with Klokan Technologies GmbH.

Support and community

The team behind OpenMapTiles is available for commercial support and consulting and can assist with deployment and applications of the maps in products and services.

Contributions to the source code from the community are very welcome!


MapTiler 7.2: Mobile apps via Google Drive


We carefully listen to our customers and there is a new MapTiler 7.2 update packed with many most wanted features!

Send your maps to a mobile phone or tablet and use it offline - directly from MapTiler user interface. The data transfer is done via Google Drive instead of Dropbox now.

Updated 7.2 version of MapTiler includes a Resume mode which means that your MapTiler will continue working where it was stopped. From now, MapTiler can also prevent deleting of unfinished tile datasets, you can set it directly from GUI or through command line with -keep_unfinished argument.

Together with this version of MapTiler, a brand new mobile app GeoEditor is released in beta-version. It display maps made with MapTiler, with possibilities to annotate the maps with features and attached photo.
The app runs on Android and iOS phones and tablets.
See more at http://www.maptiler.com/mobile/.

Vector tiles stored in MBTiles, such as those from our http://OSM2VectorTiles.org/, can be previewed just by double click on your desktop. Direct upload of the vector tiles from MBTiles into Amazon S3 or Google Cloud Storage is possible as well!

MapTiler 7.2 also includes the following features:

- Help menu in MapTiler contains online tutorials, manual and link to support

- Docker image for latest MapTiler Pro on Docker Hub for easy deployment on any Linux distro or cloud: https://hub.docker.com/r/klokantech/maptiler/

- New packages for latest versions of Fedora and Ubuntu linux

- Multi-band images such as raw satellite data supported (reorder or ignore bands)

- Added Baidu maps tile format popular in China

- Geodetic tiles preset under Custom tiles

- Latest leaflet viewer for generated tiles - including custom profile

- Corners location input for easier indoor / floor maps positioning

The updated version is now available at http://www.maptiler.com/. Try it out for free now!


Allow anyone to upload files to your Google Drive with DriveUploader.com

Do you need to get from your clients or friends gigabytes of data? We do. People send us large maps and geodata, often in tens or even hundreds of gigabytes. Now they can do that directly from a web browser, by drag&drop!

To make this possible, we’ve built a pretty cool web application named Drive Uploader which works with Google Drive™cloud storage.

Check it out at https://driveuploader.com

The uploader you create looks very familiar and you can customize the design, if you need to.

We’ve built the Drive Uploader to easily receive large files (documents, pictures, video clips, aerial photos, etc.) from customers, suppliers, colleagues, family or friends.

The sender does not need to create any account, they just visit a website and use their web browser.

The main advantages of the service are:
  • No limit on size of the files
  • No need to have a Google account for the senders
  • Extremely easy to use and integrate with websites
  • Security of the transfer (Drive Uploader uses HTTPS and private storage)
  • Files are saved directly in your Google Drive™ in the folder you choose
DriveUploader is available for free! Each upload link you create on Drive Uploader is completely free of charge for the first 3 days and you can extend the period with just one click.

Embedding in websites, branding with your logo and integration to your products is possible via API and webhooks. These advanced features are available in a paid plan, together with a removal of ads.

Every Gmail account comes with free 15 GB Drive storage and affordable upgrade plans. The business and education G Suite / Google Apps account come with unlimited cloud storage. It is time to use this storage!

So, once more - the link to try is https://driveuploader.com


MapTiler helps people to recover from the Hurricane Matthew

The U.S. Government organization NOAA (National Oceanic and Atmospheric Administration) has chosen the MapTiler software from Klokan Technologies GmbH to turn the aerial photos taken after the Hurricane Matthew into a fast and reliable mapping service offered to the press and general public during the disaster recovery actions.

The speed of generating of the map tiles, as well as the reliability and scalability of the produced mapping service are able to handle hundreds of thousands of visitors. This is the main reason why our software is used for such cases.

Processing and hosting of the aerial photos happen on the Microsoft Azure cloud on Linux virtual machines running our latest MapTiler Pro on the command line. The tiles are served from Azure platform with an open-source TileServer software. It permits fast distribution of the maps to various mashups and websites, as well as opening of the map layers in the standard GIS software such as QGIS or ESRI ArcGIS. The same map tiles are directly reused thanks to the OGC WMTS standard. See the Coastal Imagery Services.

Other customers are using our MapTiler Pro (http://www.maptiler.com/) for similar tasks on their standard desktop computers, virtual machines, in private clouds or on Amazon or Google cloud platforms.

The maps produced by MapTiler during the previous flights are also used by pilots on the board of the airplanes together with open vector maps - as an extra option to standard navigation for taking new photos. More details are available at: http://blog.klokantech.com/2016/06/noaa-pilots-use-open-source-tileserver.html


OSMNames: Place names data & geocoder

Today we launch the OSMNames open-source project which provides a basic place search / geocoding functionality.

It is a lightweight search system powered by full-text engine with world-wide coverage. At the moment it is limited to place names like streets, towns, cities, administrative units, countries, etc.. It can be extended in future with other place types like lake or mountain names and even with POIs. The enhancement with postal addresses (house numbers and zip codes) is also possible.
Try it at:

Install the software easily together with the provided global data on your own server with the docker container osmnames-sphinxsearch. The process is described in the documentation.

The OSMNames project consists of two parts:

OSMNames data available for download

The core of the OSMNames project is the pre-processed data. It comes in easy to handle text format, the TSV (tab separated value). This allows filtering with UNIX text processing tools (grep, sed, awk, less, cut, etc.) and direct indexing via a full-text search engine.

You can download the data at http://osmnames.org/download/

It contains over 21 million gazetteer records with lat/lon location, bounding box, names in several languages, identifiers for OSM and Wikidata, etc. All the records are sorted by precalculated numerical importance (derived from Wikipedia and existing Nominatim ranking). Our website recommends how to filter the data by country, geographical location or type to create smaller extracts.

Search engine software

The project comes with an open-source server software providing a place search API suitable for a basic geocoder with autocomplete functionality. The server is written in Python and is powered by the high-performance C++ open-source full-text engine called Sphinx Search.

The OSMNames project is a result of the cooperation of Klokan Technologies GmbH and HSR Rapperswil.

Klokan Technologies GmbH is using the service in products such as MapTiler or Georeferencer. We are excited to release it now and hope more users can help us to make it even better! Hope to see OSMNames adopted by more individuals and companies soon.


TileServer GL: Maps with GL JSON styles from your server

New open-source project TileServer GL has just been released in version 1.0 at the FOSS4G conference and is available on our GitHub:


With TileServer GL you can host vector tile maps on your own infrastructure, under your control, or even completely offline. The software takes care of serving the vector maps (PBFs, GL JSON styles, and all the assets), but also provides server-side rasterized tiles as a fallback.

Raster tiles look exactly the same as vector maps and are generated from vector tiles and GL JSON style on the server side with the MapBox GL Native rendering core made in C++.

The vector tiles allow for nicer maps, with a higher degree of interactivity and also decrease bandwidth to your server. The vector maps can be used in several web mapping libraries such as MapBox GL JS or OpenLayers 3 as well as native mobile applications for Android or iOS. The raster tiles can be used in almost any software including Leaflet or GIS tools (via XYZ, TileJSON, WMTS).

This way you can transition to the vector tiles wherever possible, but still have the raster tiles with the same look & feel without the need to write the map style twice in a different format.

The server can be easily set up to provide several different styles (in a modern GL JSON format), so you can have multiple maps for different use cases served from a single set of vector tiles. There are also endpoints serving static raster maps with the possibility to add polygon overlays simply by adding parameters to the URL. All the endpoints support scaling parameters so you always have HiDPI/retina, print-ready maps at your disposal.

The TileServer GL relies on other open-source projects, which have been under development for years. Most notably mapbox-gl-native, which we use for the server-side rendering and mapbox-gl-js which is default viewer for vector tiles.

This video shows in the first two minutes how easy it is to run your own map server using TileServer GL with open-data tiles downloaded from OSM2VectorTiles:

All what you need is a single docker command:

docker run -it -v $(pwd):/data -p 8080:80 klokantech/tileserver-gl

Feel free to try our TileServer GL live instance at https://maps.klokantech.com/.

It's also possible to combine multiple input sources (MBTiles; tiles from Amazon S3 or GCS; dynamic tiles from GeoServer, MapServer, ...) to create complex or even hybrid maps (satellite maps with labels). The whole stack is usable with custom coordinate systems as well!

If you are interested to know more watch the complete video recording of our presentation from FOSS4G at https://youtu.be/rOg4VnSAnI4.

Considering transition to vector tiles? Do you want production deploy of TileServer GL? Need to render your own vector or raster tiles? Contact us at info@klokantech.com!


Blue-Green Deployment with Docker and Nginx

Here at Klokan Technologies, we mostly develop software services and we run them as Docker containers. To release new versions, we use the blue-green deployment technique. This reduces downtime and limits the impact of configuration errors.
The basic idea is simple. Instead of having just one production environment, there are two identical ones: blue and green. They take turns actively running the service. A new version is deployed to the environment that is not currently active. Only after the service successfully starts up there and passes all health checks is that environment marked as active. The old active environment is then stopped and prepared to receive the next deployment.
The switch from one environment being active to the other one is a crucial step. If it’s not atomic, there will be a short period where neither environment is active and any request coming in at this time will fail. We use Nginx for this purpose because it does have this capability and because we have it as a reverse proxy anyway.


To illustrate the whole process, let us consider an example. We will deploy a Python application in a file called hello.py, listed below. It listens for HTTP requests on port 9000 and responds with a greeting, providing a simple service.

$ cat hello.py
from wsgiref.simple_server import make_server

GREETING = b'Hello, world!\n'

def hello(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/plain')])
    return [GREETING]

make_server('', 9000, hello).serve_forever()

We will have one container for the application and one for Nginx. We will put both on the same Docker network, so that they can see each other. In our production environment, we have separate backend and frontend networks, but it is not necessary here. We will use official Docker images.

$ docker network create example
$ docker pull nginx
$ docker pull python:3

First we start the application itself in the BLUE environment. Notice that we name the container hello-BLUE.

$ docker run \
    --name hello-BLUE \
    -v $(pwd)/hello.py:/usr/local/src/hello.py \
    --net=example \
    -d \
    python:3 \
    python /usr/local/src/hello.py

Then we put the application configuration for Nginx into a file called nginx-conf.d/hello.conf. It sets up an HTTP proxy that forwards all requests to the application. Here again, we have to refer to the application container as hello-BLUE.

$ cat nginx-conf.d/hello.conf
server {
    listen 80;
    location / {
            proxy_pass http://hello-BLUE:9000;

Now we can start Nginx. It will read the configuration file we have just created and publish the application proxy on port 8080.

$ docker run \
    --name nginx \
    -v $(pwd)/nginx-conf.d:/etc/nginx/conf.d \
    --net=example \
    -p 8080:80 \
    -d \

See that it works.

$ curl http://localhost:8080
Hello, world!

Now we make a new version of the service by changing the greeting in the hello.py file.

$ cat hello.py
from wsgiref.simple_server import make_server

GREETING = b'Hello, world! (VERSION 2)\n'  # <=== Change here

def hello(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/plain')])
    return [GREETING]

make_server('', 9000, hello).serve_forever()

We start the application again, this time in the GREEN environment. Notice the change in the container name. Otherwise the command is the same as before.

$ docker run \
    --name hello-GREEN \  # <=== Change here.
    -v $(pwd)/hello.py:/usr/local/src/hello.py \
    --net=example \
    -d \
    python:3 \
    python /usr/local/src/hello.py

We have to change the name of the application container in the Nginx configuration as well.

$ cat nginx-conf.d/hello.conf
server {
    listen 80;
    location / {
            proxy_pass http://hello-GREEN:9000;  # <=== Change here

Before switching active environments, we must check that the configuration is correct and that the application is reachable. There is an Nginx command line option for that, so we run it in a temporary container.

$ docker run \
    --rm \
    -v $(pwd)/nginx-conf.d:/etc/nginx/conf.d \
    --net=example \
    nginx \
    nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

If the check was successful we send the Nginx container a SIGHUP signal. This will make it re-read the configuration and restart itself without dropping any requests.

$ docker kill -s HUP nginx

And we can see that we have a new version deployed.

$ curl http://localhost:8080
Hello, world! (VERSION 2)

The BLUE environment is no longer needed, so we remove it.

$ docker stop hello-BLUE
$ docker rm hello-BLUE


In our example, we only had one application container for the service. There could be more and they would all be manipulated together. There could also be more services running on the same machine. They would each have its own BLUE and GREEN environments.
The Nginx container and other infrastructure containers with state are not deployed using this technique. This includes databases and most caches. We can’t stop or restart databases because the active environments are using them even during the switch, and we usually don’t want to clear caches on each deployment.
There is more to making this approach viable for automated deployment. We haven’t mentioned how to determine which environment is currently active for a given service and machine. Also, manually editing configuration files before each deployment is clearly not the way to go. At Klokan Technologies, we actually use Ansible with a custom module to solve both problems, but that is a story for another day.