GraphHopper Routing Engine
GraphHopper is a fast and memory efficient Java routing engine, released under Apache License 2.0. By default it uses OpenStreetMap and GTFS data, but it can import other data sources.
To get started, read through our documentation and install the GraphHopper Web Service locally:
- unstable: documentation, web service jar, Android APK
- 0.11.0 latest stable: announcement, documentation, web service jar, Android APK
- 0.10.0: announcement, documentation, web service zip, Android APK
- 0.9.0: announcement, documentation, web service zip, Android APK
- 0.8.2: announcement, documentation, web service zip, Android APK
- 0.7.0: announcement, documentation, web service zip, Android APK
All questions can go to our forum where we also have subsections specially for developers, mobile usage (iOS&Android), and our map matching component. Another place to ask questions would be on Stackoverflow, but please do not use our issue section. Create new issues only if you are sure that this is a bug. Also, see how to contribute in the next section.
Read through how to contribute for information on topics like finding and fixing bugs and improving our documentation or translations!
For the Web
See GraphHopper in action on GraphHopper Maps
GraphHopper Maps uses the Directions API for Business under the hood, which provides a Routing API via GraphHopper, a Route Optimization API via jsprit, a fast Matrix API and an address search via Photon. Additionally, map tiles from various providers are used where the default is Omniscale. All of these are available for free, via encrypted connections and from German servers for a nice and private route planning experience!
For Public Transit
For Mobile Apps
There is the isochrone subproject to calculate and visualize the reachable area for a certain travel mode
GraphHopper supports several routing algorithms, such as Dijkstra and A
* and its bidirectional variants. Furthermore, it allows you to use Contraction Hierarchies (CH) very easily. We call this speed mode; without this CH preparation, we call it flexible mode.
The speed mode comes with very fast and lightweight (less RAM) responses, although it does not use heuristics in its default settings. The downsides are that the speed mode allows only pre-defined vehicle profiles (multiple possible in GraphHopper) and requires a time consuming and resource-intensive preparation. Finally, implementing certain features is not possible or very complex compared to the flexible mode.
The hybrid mode also requires preparation time and memory, but it is much more flexible regarding changing properties per request or e.g. integrating traffic data and more. Furthermore, this hybrid mode is slower than the speed mode, but it is an order of magnitude faster than the flexible mode and uses also less RAM for one request.
You can switch between all modes at request time.
We chose the Apache License to make it easy for you to embed GraphHopper in your products, even closed source. We suggest that you contribute back your changes, as GraphHopper evolves fast, but of course this is not necessary.
OpenStreetMap is directly supported from GraphHopper. Without the amazing data from OpenStreetMap, GraphHopper wouldn't be possible at all. Other map data will need a custom import procedure, see e.g. Ordnance Survey, Shapefile like ESRI or Navteq.
Written in Java
GraphHopper is written in Java and runs on Linux, Mac OS X, Windows, BSD, Solaris, Raspberry Pi, Android, Blackberry, and even iOS.
Embed GraphHopper with OpenStreetMap support into your Java application via the following snippet:
<dependency> <groupId>com.graphhopper</groupId> <artifactId>graphhopper-reader-osm</artifactId> <version>[LATEST-VERSION]</version> </dependency>
If you want to write your own import procedure or you don't need OSM import like on Android, then use:
<dependency> <groupId>com.graphhopper</groupId> <artifactId>graphhopper-core</artifactId> <version>[LATEST-VERSION]</version> </dependency>
We've built the GraphHopper class which makes simple things easy and complex things like multi-modal routing possible. Still, you can use the low level API of GraphHopper and you'll see that it was created to allow fast and memory efficient use of the underlying data structures and algorithms.
Android / Blackberry
On Android and Blackberry (since 10.2.1), we provide an integration with Mapsforge which makes offline navigation one step closer. Due to the usage of memory mapped files and Contraction Hierarchies, we avoid allocating too much memory. This makes it possible to run Germany-wide queries with only 32MB in a few seconds. We provide an Android studio project as well as the Maven-Android integration to be used in other IDEs.
Web UI and API
GraphHopper also runs on the Desktop in a Java application without internet access. E.g. you could use the rough user interface called MiniGraphUI provided in the tools module, see some visualizations done with it here. A fast and production ready map visualization for the Desktop can be easily implemented via mapsforge.
Install GraphHopper via Docker. You only need to change the docker-compose.yml entrypoint in core/files/ to run whatever map you like. Then just type:
cd core/files/ docker-compose up -d
If you don't want to use docker-compose you can do the following:
docker build -t graphhopper:master . docker run -d --name graphhopper -v <path_data_directory>/data:/data -p 11111:11111 graphhopper:master
Here is a list of the more detailed features including a link to the documentation:
- Simple start for users - just Java necessary! Simple start for developers due to Maven.
- Works out of the box with OpenStreetMap (osm/xml and pbf) but can be adapted to use your own data
- OpenStreetMap integration: Takes care of the road type, the surface, barriers, access restrictions, ferries, conditional access restrictions, ...
- GraphHopper is fast. And with the so called "Contraction Hierarchies" it can be even faster (enabled by default).
- Memory efficient data structures, algorithms and the low and high level API is tuned towards ease of use and efficiency
- Multiple weightings (fastest/shortest/...) and pre-built routing profiles: car, bike, racingbike, mountain bike, foot, motorcycle, ...
- Support for public transit routing and GTFS support.
- Offers turn instructions in more than 35 languages, contribute or improve here
- Displays and takes into account elevation data (per default disabled)
- Can apply real time changes to edge weights (flexible and hybrid mode only)
- Customize vehicle profiles per request (flexible and hybrid mode only)
- Possibility to specify a heading parameter of the vehicle for start, end and via points for navigation applications via
headingparameters (flexible and hybrid mode only)
- Alternative routes (flexible and hybrid mode only)
- Turn costs and restrictions (flexible and hybrid mode only)
- Country specific routing via SpatialRules
- Multiple profiles and weightings
- Several pre-built routing profiles: car, bike, racingbike, mountain bike, foot, motorcycle, ...
- The core uses only a few dependencies (hppc, jts and slf4j)
- Scales from small indoor-sized to world-wide-sized graphs
- Find nearest point on street e.g. to get elevation or 'snapp to road'
- Do map matching with GraphHopper
- Calculate isochrones with GraphHopper