#vrp #optimization


A core algorithms to solve a Vehicle Routing Problem

48 stable releases

1.10.7 Jul 12, 2021
1.10.4 May 15, 2021
1.9.1 Mar 24, 2021
1.7.2 Dec 5, 2020
1.4.1 Jul 30, 2020

#131 in Algorithms

Download history 53/week @ 2021-04-07 159/week @ 2021-04-14 84/week @ 2021-04-21 90/week @ 2021-04-28 9/week @ 2021-05-05 77/week @ 2021-05-12 17/week @ 2021-05-19 5/week @ 2021-05-26 3/week @ 2021-06-02 48/week @ 2021-06-09 26/week @ 2021-06-16 32/week @ 2021-06-23 4/week @ 2021-06-30 25/week @ 2021-07-07 55/week @ 2021-07-14 9/week @ 2021-07-21

187 downloads per month
Used in 4 crates


11K SLoC


The core crate contains main buildings blocks for constructing heuristics and metaheuristic to solve rich Vehicle Routing Problem.

Please check the repository for more details.


A core crate contains main buildings blocks for constructing heuristics and metaheuristic to solve rich Vehicle Routing Problem.

Key points

A basic idea of the core crate is to design a library which can be used to solve multiple variations of Vehicle Routing Problem (VRP) known also as a rich VRP. In order to achieve that, it defines essential domain models and implements default metaheuristic with preconfigured properties.

Another goal is an intuitive design: it should be relatively easy to start using it without prior knowledge of the domain. That's why the API design does not try to generalize models and implementations in order to develop a general purpose metaheuristic.

Extra functionality, already developed on top of this crate, is available via following crates:

  • vrp-scientific crate supports VRP variations used in scientific benchmarks
  • vrp-pragmatic crate supports custom json format which can be used to model real world scenarios
  • vrp-cli crate provides a command line interface and static library with all available functionality provided by the project

Meanwhile, the project tries to keep the list of dependencies relatively small, but "Not invented HERE" syndrome should be also avoided.

The next sections explain some basic concepts such as types used to model VRP definition, constructive heuristics, metaheuristic, etc. Start exploring them, if you are curious about internal implementation or library extension. It you are looking just for user documentation, check! the user guide documentation.

Modeling VRP

Model definitions can be split into three groups:

  • common group contains common models: time-specific, location, distance, etc.
  • problem group contains VRP definition models: job, vehicle, cost-specific, etc.
  • solution group contains models which used to represent a VRP solution: route, tour, activity, etc.

Check corresponding modules for details.

Constructive heuristic

A constructive heuristic is a type of heuristic method which starts with an empty solution and repeatedly extends it until a complete solution is obtained.

The crate implements various constructive heuristics in construction module.


A metaheuristic is a high-level algorithmic framework that provides a set of guidelines or strategies to develop heuristic optimization algorithms. One of its goals is to guide the search process towards optimal solution.

See more details about it in solver module.


The most simple way to run solver is to use Builder. You can tweak metaheuristic parameters by calling corresponding methods of the builder instance:

# use vrp_core::models::examples::create_example_problem;
# use std::sync::Arc;
use vrp_core::solver::Builder;
use vrp_core::models::Problem;
use vrp_core::utils::Environment;

// create your VRP problem
let problem = create_example_problem();
let environment = Arc::new(Environment::default());
// build solver to run 10 secs or 1000 generation
let solver = Builder::new(problem, environment)
// run solver and get the best known solution within its cost.
let (solution, cost, _) = solver.solve()?;

assert_eq!(cost, 42.);
assert_eq!(solution.routes.len(), 1);
assert_eq!(solution.unassigned.len(), 0);
# Ok::<(), String>(())


~46K SLoC