At present, in CartoType 8.4, online data is supported by using CartoType to serve bitmap tiles, which can then be drawn by any standard slippy-map system.

The next release, scheduled for summer 2023, includes more flexible support for online data on any platform. The new system is called CartoType Online

How CartoType Online works

A CartoType app opens a map, supplying a URL instead of a file name, for example,, and everything works as usual. The server supplies vector tiles and handles searches and routing requests. Mobile applications benefit by not needing to store large maps locally.

There are some advantages over serving bitmap tiles:

  • The map can be in any projection. Bitmap tiles usually require a Web Mercator projection.
  • You can use any style sheet, or change the style at run-time. Bitmap tiles are always in a fixed style.
  • When you rotate the map, labels remain horizontal. 
  • The server uses much less disk space than a typical tile server. No tile cache is required.
  • You can add data to the map at run-time, or combine the map with local data such as pushpins or annotations.

The client is an ordinary CartoType app on any platform. The server application is an executable that is run by the main server program, such as Apache, NGINX, or Windows IIS, via the FastCGI protocol. Stand-alone server systems can also be provided.

Please contact us for more information.


Nvidia's Jetson embedded computing boards can run CartoType, with full support for hardware-accelerated graphics. We do not build the CartoType SDK for Jetson as part of our regular release process, so if you need an evaluation CartoType SDK for Jetson please contact us and we'll send it to you. It's a standard Linux SDK built for the Jetson architecture.

You'll need to install the Mesa libraries to support the OpenGL ES 2.0 graphics system:

sudo apt-get install mesa-dev
sudo apt-get install mesa-utils-extra
sudo apt-get install libgles2-mesa-dev

If you want to run the demonstration program you'll also need to install the Code::Blocks IDE and the GLFW library:

sudo apt-get install codeblocks
sudo apt-get install libglfw3-dev

... then load the project file unix_gl_demo.cbp into Code::Blocks, and change the libraries in the Linker Settings section of the CodeBlocks build options to


The mapinfo tool allows you to analyse the structure and content of CartoType maps (CTM1 files), search them for specified map objects, and get the total area or length of a group of map objects. For example, you can get the total length of all roads, list the layers in the map, or find out what type of routing data is stored.

Download mapinfo:

mapinfo for Windows
mapinfo for 64-bit Linux
mapinfo for mac OS 

To uninstall mapinfo just delete the executable.

By using the CartoType mapinfo tool (mapinfo.exe, mapinfo_mac, mapinfo_linux, ctm1_info.exe, etc., or any other variant, not necessarily having one of the names listed here), however acquired, you accept the terms of the CartoType Evaluation License and you also accept that neither CartoType Ltd, nor any owners, shareholders or officers of CartoType Ltd, or any other contributors to, authors of or maintainers of the CartoType system, are liable for any damage, direct or consequential, caused by downloading, installing or using the mapinfo tool, and that the mapinfo tool is not warranted fit for any particular use and may not be used for any commercial purpose without the purchase of a CartoType license.

Find out how to create CartoType maps here.


This release was made on 15th September 2020 and is based on mainline revision 9241.

The previous release, 6.0, was made on 6th July 2020 and was based on mainline revision 9085.


Note: these changes were made between release 6.0 and release 6.2. Some of them were merged into release 6.2.

Improvements to the TECH router. The TECH (turn-expanded contraction hierarchy) router, which you can use via the makemap command line option '/route=tech', now incurs much lower peak RAM use in makemap when the data is being created.

General router improvements. Turn costs and instructions and junction information are now consistent over all router types apart from the CH router, which does not support turn costs. A-star routing is now faster, and is as fast for vehicle types containing maximum weights or other dimensions as for those without. However, as explained below, A-star routing is now deprecated: use /route=t instead of /route=a or /route=yes, which is the same thing.

Deprecation of non-turn-expanded routers. The two recommended router types are now /route=t: turn-expanded A-star, supporting flexible routing profiles at runtime; and /route=tech: turn-expanded contraction hierarchy, for lower RAM use and very fast routing at the cost of larger CTM1 files and a fixed set of routing profiles decided at map creation time. The other types of router data (/route=a and /route=ch) are still however supported and can be created by makemap and used by the CartoType library. The reasons for their deprecation are that neither of them can create correct routes in certain circumstances involving complex junctions, and that the CH router does not support turn costs. This deprecation policy means that there will be no further development effort for the deprecated routing systems.

New containment and intersection functions for map objects. There are now functions to determine the way a path, represented by a Geometry object, intersects with a map object or list of map objects. Intersection and  containment are distinguished, and in the case of non-intersection the distance and closest points are found.

Maps can now straddle the antimeridian. Countries like Russia, the USA and Fiji have territories on both sides of the antimeridian at 180 degrees West or East. To create maps straddling the antimeridian use longitude values greater than 180 for the eastern edge, and use an appropriate projection (e.g., Lambert Azimuthal Equidistant for Fiji: /project=laea, or Albers Equal Area for Russia; see

Most out-of-memory exceptions are now trapped. The operations of routing, loading a map, and finding large numbers of map objects are now performed inside try...catch constructs so that out-of-memory conditions are reported as error codes rather than causing program termination. This is principally relevant to mobile platforms (iOS and Android) but happens on all platforms.

Selected other changes and fixes

fixed case 2694: TECH router doesn't handle changes to the traffic light time correctly; logic for deciding whether a turn was cross-traffic was wrong
implemented case 2664: makemap should write the CartoType version used to build the CTM1 file
fixed case 2704: One way restriction not being followed
implemented case 2688: makemap should use information in GeoTIFF files in preference to world files
fixed case 3717: TileBitmap doesn't support night mode
fixed case 3718: wrong route time on tech map
fixed case 3719: wrong route calculated with tech maps; only the first positive turn restriction was handled by FixRestrictions, so second and subsequent positive restrictions were ignored
fixed case 3715: high RAM use when zoomed out in a very large map
fixed case 3722: extra turns in cycling route
fixed flickering when drawing labels using latest Qt 5.15; supplement to case 2626: display flickers in web assembly
fixed case 3725: route geometry is incomplete
fixed case 3735: a-star router adds five minute delay at end of route
prevented a long sequence of deprecated roads (speed plus bonus = 0) from being used
fixed case 3738: memory map database ignores condition when deleting entire range of object IDs
made admin areas relevant when searching for localities and sub-localities in FindAddress: fixed case 3733: Diemelstadt not found; Diemelstadt is a municipality, which becomes TGeoCodeType::AdminArea8
fixed case 3729: FindAddress doesn't merge streets properly
fixed case 3740: FindAddress sets a very large margin around cities
the windows demo and the maps app now create a non-overlapping envelope for found linear objects
the maps app didn't enable 'find next' for address finding
fixed case 3741: FindAddress doesn't find roads by reference
fixed case 3732: CreateRoute crashes with coordinate outside the map
fixed case 3730: FindAddress can't find Frankfurt (Oder); space is now used as a separator when matching tokens in a name
fixed case 1963: make nearby object warnings work even when not navigating
implemented case 3708: add option to maps app to use shift-left-click to simulate a location fix
maps app now shows the current navigation state when simulating a route
fixed case 2667: loading a custom route profile in maps app when custom routing is selected doesn't change the route
fixed case 3742: some graticule lines are not displayed when graphics acceleration is on
fixed case 3744: LoadIcon doesn't work when TileBitmap is used

This release was made on 6th July 2020 and is based on mainline revision 9085. It includes support for Web Assembly, faster and lower-memory map creation, and faster routing.

The previous release, 5.12, was made on 25th March 2020 and is based on mainline revision 8838.


CartoType is now available as a web assembly library in the desktop version of the Chrome browser. There's a simple demonstration here. It enables you to provide CartoType mapping and routing capabilities to your users in a browser window without asking them to install anything.

The web assembly version of CartoType is full-featured and contains everything that the other versions have on Windows, iOS, Android, and Linux.


This release was made on 25th March 2020 and is based on mainline revision 8838.

The previous release, 5.10, was made on 15th October 2019 and was based on mainline revision 8479.


Sometimes you need the power of a full programming language when importing data. For example, you might need to load an ESRI shapefile, read records with a matching key in an associated DBF file, and loop through the records. The ChaiScript language, which can be used anywhere suitable in a CartoType makemap file inside the element <script> ... </script>, allows you to do that. It's very similar to C++, with some differences (e.g., 'int x = 0' in C++ becomes 'auto x = int(0)' in ChaiScript; there are no postincrement or postdecrement operators; etc.). This article explains the functions added to ChaiScript to make data import possible. General notes on the ChaiScript language are found on another page


This document describes ChaiScript, an open-source (BSD license) scripting language invented by Jason Turner. It was written by examining the ChaiScript source code and searching the internet for examples and explanations. Any inaccuracies are the fault of the author.


This release was made on 15th October 2019 and is based on mainline revision 8479.

The previous release, 5.8, was made on 26th April 2019, based on mainline revision 8175.


This release on 26th April 2019 is based on mainline revision 8175.

Previous release 5.6 on 11th February 2019 was based on mainline revision 7972.


Release date: 12th February 2019

Previous release: 5.4, 23rd October 2018


Isochrones (travel ranges) now work for the turn-expanded router

Turn-expanded router data can now be stored in serialized form, for fast loading, in CTM1 (map) files

Address data can be added to map objects at data preparation time for use by a new function, GetAddressFast, which uses data only from the map object for which an address is required


Release date: 23rd October 2018

Previous release: 5.2, 12th July 2018

Summary of changes

SetScaleBar, SetLegend, SetCopyright and other new functions allow scale bars, legends (map keys) and copyright notices to be added to the map easily, and to be displayed properly when using hardware graphics acceleration.

Boxed labels for point objects can now optionally have small triangular pointers which indicate the exact position of the point object.


It's possible to use the makemap tool to create very large CartoType maps (CTM1 files), up to and including a map of the whole world using the full OpenStreetMap data file planet.osm. The easiest and fastest way is to use lots of RAM.


CartoType's graphics acceleration system gives you a smooth, fast, fluid user experience, with no delays when panning or zooming the map. Drawing speeds of up to 30 frames per second are supported.


This document explains the CartoTypeRouteProfile XML format, used in .ctprofile files. These files are used to store route profiles, which are used to customize the behavior of the route calculation system. For example, it's possible to make some types of roads more or less preferable than others, or to forbid them entirely, and to set the type of vehicle, for instance to a car, heavy goods vehicle or bicycle.


Here are answers to some questions frequently asked about CartoType.


CartoType uses a standard set of map layers and attributes. These are used by the import rules built into makemap, and by the standard style sheet. You can override them completely by using your own import rules and style sheets, but it is better to use the standard set, adding new layers and attributes where needed, or omitting unnecessary ones. The reason for using the standard set is that they used by the address searching system. In general, attributes and layers are described according to how they are imported from OpenStreetMap data.


Apple introduced the Swift programming language in 2014. It has now largely replaced Objective C to become the language of choice for iOS applications. However, CartoType's iOS API is written in Objective C. This article explains how to use the CartoType iOS SDK in a Swift project. You can use CartoType completely from Swift. There is no need to write any Objective C.