Register for 2015 Competition

Classic Track CFP

Software - Classic Track

Competition Results

Important Links
Grid-Based Pathfinding Benchmark Problems
2012 GPPC Entries
2013 GPPC Entries

Related Conferences

GPPC: Grid-Based Path Planning Competition

                            Classic Track


A wide variety of researchers have used grid-based maps as testbeds
for search and they are also used in many deployed applications. There
has been, however, a shortage of comparisons between existing work,
and many published techniques may not apply in more real-world
situations. The advent of widely available benchmark problems
( is one step towards encouraging comparison
between existing approaches.

The third annual grid-based path planning competition will be held in
2014, with the goal of furthering comparisons between existing work
and encouraging the publication of code for fast pathfinding

Teams are required to register for the competition by midnight December 1
(UTC-12).  Entries must be finalized by midnight December 15 (UTC-12).
But, entries can be submitted at any time prior to this.

The competition will be run with the following constraints:

* Maps will be at most 2048x2048.
* The maps will be static (unchanging).
* Maps will be 8-connected; in order to move diagonally, both adjacent
  cardinal directions must be unblocked.
* Diagonal actions in an optimal path cost sqrt(2).
* The competition will be broken into pre-processing and testing phases.
** In the pre-processing phase, entries will pre-process a map, writing
   any necessary files to disk.
** In the testing phase, entries can load the pre-processed data from
   disk to use for path planning.
** Pre-processing time and disk limits have been lifted, but the use of
   significant resources may delay your results.
* All entries will be made available as open source after the competition.
* Programs must be written in C/C++ or be written to link to sample
  code from which the tournament will be run.

Sample code for the competition is available from:

The sample code performs three main calls to the code provided in a
tournament entry:

void PreprocessMap(std::vector &bits, int width, int height,
                   const char *filename);
void *PrepareForSearch(std::vector &bits, int width, int height,
                       const char *filename);
bool GetPath(void *data, xyLoc s, xyLoc g, std::vector &path);

The main.cpp sample file should not be modified as it may be replaced
for the actual competition. Each entry should include a makefile for
compiling the code for the competition.

If participants wish to enter using a different language besides C/C++,
they should contact the tournament organizer .

Instead of competing on a particular metric, metrics will be computed
about the performance of each entry in the competition. Dominated
entries (which are worse than some other program in all metrics) will
be noted, but the remaining entries are all considered viable
approaches depending on the metrics required for a particular domain.

The metrics tested will include:

* The total time to find a complete path.
* The time to find the first 20 steps of the path.
* The maximum time for returning any portion of a path.
* The total path length (suboptimality).
* The total memory (RAM) usage.
* The total disk usage.
* The pre-processing time.

To register for the competition, please fill out the entry form at:

Previous GPPC entries are available at:

GPPC Chair:
Nathan Sturtevant, University of Denver