Open-source vehicle routing software

If you want to write your own solver

OR-Tools is Google's own combinatorial optimization library — the same one this tool is built on. Its routing module handles vehicle routing with time windows and capacity constraints out of the box, in Python, C++, Java, or .NET.

This is real, unrestricted, self-hostable software. If you want full control — your own server, your own data handling, your own UI — this is the honest starting point, not a hosted tool.

A working OR-Tools VRP example in Python

This is a complete vehicle routing problem with time windows and capacity: two vehicles, five stops, a travel-time matrix in minutes, a delivery window for each stop, and a load limit per vehicle. Run pip install ortools, save it as a file, and run it. I tested it on OR-Tools 9.15.

from ortools.constraint_solver import pywrapcp, routing_enums_pb2

# Travel times in minutes. Node 0 is the depot.
time = [
    [0, 12, 18, 25, 14, 20],
    [12, 0, 10, 22, 16, 24],
    [18, 10, 0, 15, 20, 17],
    [25, 22, 15, 0, 13, 11],
    [14, 16, 20, 13, 0, 9],
    [20, 24, 17, 11, 9, 0],
]
windows = [(0, 480), (60, 180), (0, 120), (240, 360), (30, 150), (200, 400)]  # minutes after 8:00
demand = [0, 4, 3, 5, 2, 6]
capacity = [10, 10]          # two vehicles
service = 10                 # minutes at each stop

manager = pywrapcp.RoutingIndexManager(len(time), len(capacity), 0)
routing = pywrapcp.RoutingModel(manager)

def transit(i, j):
    a, b = manager.IndexToNode(i), manager.IndexToNode(j)
    return time[a][b] + (service if a != 0 else 0)
t = routing.RegisterTransitCallback(transit)
routing.SetArcCostEvaluatorOfAllVehicles(t)

# Time dimension: vehicles may wait (slack), and every route ends by minute 480.
routing.AddDimension(t, 480, 480, False, "Time")
td = routing.GetDimensionOrDie("Time")
for node, (open_, close) in enumerate(windows):
    if node:
        td.CumulVar(manager.NodeToIndex(node)).SetRange(open_, close)
for v in range(len(capacity)):
    td.CumulVar(routing.Start(v)).SetRange(*windows[0])

# Capacity dimension.
d = routing.RegisterUnaryTransitCallback(lambda i: demand[manager.IndexToNode(i)])
routing.AddDimensionWithVehicleCapacity(d, 0, capacity, True, "Load")

params = pywrapcp.DefaultRoutingSearchParameters()
params.first_solution_strategy = routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
params.local_search_metaheuristic = routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
params.time_limit.seconds = 5

sol = routing.SolveWithParameters(params)
if sol is None:
    raise SystemExit("No feasible routes: loosen a time window or add a vehicle.")
for v in range(len(capacity)):
    i, stops = routing.Start(v), []
    while not routing.IsEnd(i):
        stops.append(f"{manager.IndexToNode(i)}@{sol.Min(td.CumulVar(i))}")
        i = sol.Value(routing.NextVar(i))
    stops.append(f"0@{sol.Min(td.CumulVar(i))}")
    print(f"vehicle {v}: " + " -> ".join(stops))

It prints each vehicle's route with the arrival minute at every stop:

vehicle 0: 0@0 -> 4@30 -> 2@60 -> 3@240 -> 0@275
vehicle 1: 0@0 -> 1@60 -> 5@200 -> 0@230

Three things trip people up when they move from this toy to real data:

• Waiting is slack. The first argument after the callback in AddDimension is how long a vehicle may wait. Set it too low and a stop that opens late makes the whole problem infeasible, and SolveWithParameters quietly returns None.
• Integers only. Callbacks must return whole numbers. Scale minutes, meters or kilograms before you pass them in.
• The matrix is the hard part. OR-Tools doesn't know about roads. You supply the travel times, usually from a routing engine such as OSRM. That, plus reading stops from a spreadsheet and drawing the routes on a map, is most of what the hosted tool adds.

If you just want routes, right now, free

If writing and hosting your own solver isn't what you're after, that's what the tool on this page is for. It's a free web app I built on top of OR-Tools — you upload a workbook of stops, it solves the routes, you get back a map and a results file. No account, no cost.

Other open-source VRP libraries: VROOM and jsprit

I haven't run all of these myself — mentioning them because they come up in the same search, not as a personal endorsement. OR-Tools is the one I know well because it's what this tool runs on.

Why this tool is free even though it isn't open source

I'm an operations research analyst who spent twenty years building routing and scheduling models in Excel for manufacturers and airlines. Converting them into free, hosted web tools — and writing up how each conversion went — is the project. Hosting them is real, ongoing cost, which is part of why the app itself isn't a public repo; the OR-Tools library underneath it, which Google maintains and funds, is a different story and genuinely open.

Questions? Email mario@kindoflost.com. I read them.

Other routing use cases

Same solver and engine, different worked example — each of these is written for its own setting. Start from whichever is closest to yours.

• Food banks & food rescue — Home-delivery and donor-pickup routing for volunteer drivers.
• Spreadsheet-in, spreadsheet-out — Upload an Excel file of stops, get back a routed workbook and a map.
• Last-mile delivery routing — Parcel and package delivery, per-van capacity and time windows.
• Field service routing — Technician appointment windows, job duration, and per-tech capacity.
• Delivery route planner — For small businesses running their own delivery routes.
• Fleet route optimization — Multi-vehicle trucking and distribution fleets.
• Sales rep route planner — Outside sales reps and merchandisers visiting client sites.
• Courier routing software — Same-day and multi-stop courier services.
• Waste & recycling collection routing — Truck capacity and collection time windows.

Related

• Route optimizer — the tool itself, with the full parameter reference.
• VRP spreadsheet solver — more on the spreadsheet-in, spreadsheet-out workflow.
• Kind of Lost — write-ups of each model, including how this one was built.