> ## Documentation Index
> Fetch the complete documentation index at: https://maps.solvice.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Changelog

> Powering route optimization systems with blazing fast distance matrix calculations

## Changelog

<Update label="2026 Q2" description="v1.3.0">
  ## Real-time Traffic Routing

  ### New `TOMTOM_REAL_TIME` Engine

  A new routing engine that reflects **live traffic conditions** at the moment of the request, powered by TomTom's real-time feed.

  * Available on `POST /route` and `POST /table/sync`.
  * `departureTime` is ignored — every request uses *now* as the departure time.
  * Not supported on `POST /route/batch` or the async `POST /table` (real-time matrices are sync-only and not cacheable).

  ### Usage

  Set `"engine": "TOMTOM_REAL_TIME"` on the request:

  ```json theme={null}
  {
    "coordinates": [
      [4.35171, 50.85034],
      [4.40269, 50.83712],
      [4.44216, 50.63650]
    ],
    "sources": [0, 1],
    "annotations": ["duration"],
    "engine": "TOMTOM_REAL_TIME"
  }
  ```

  ### Matrix Constraints (`/table/sync`)

  * `sources` is required and must be contiguous starting from `0`.
  * The result has shape `sources × (coordinates − sources)` — sources first, destinations next; no square padding.
  * `annotations` must not include `"distance"`; the real-time feed does not return distances.
  * The `destinations` filter field is not supported.
  * Billing is per actual destination count.

  See the [Route](/route/intro) and [Matrix](/table/intro) introductions for full examples.
</Update>

<Update label="2026 Q1" description="v1.2.0">
  ## New Engines, Synchronous Cube & Road Exclusions

  ### New Routing Engines

  Support for additional routing engines beyond the default OSM-based engine:

  * **Google** — leverage Google's routing for comparison or production use
  * **Anymap** — Solvice's proprietary engine with advanced traffic modeling
  * **Custom** — bring your own engine via a custom integration

  ### Synchronous `/cube/sync` Endpoint

  A new synchronous cube endpoint for smaller, real-time cube requests — no polling required. Ideal for on-the-fly time-dependent matrix lookups.

  ### Road Type Exclusions

  Fine-grained control over which road types to avoid:

  * `toll` — avoid toll roads
  * `motorway` — avoid motorways / highways
  * `ferry` — avoid ferry crossings
  * `tunnel` — avoid tunnels
  * `bridge` — avoid bridges

  ### `departureTime` & `interpolate` Parameters

  Route and table endpoints now accept `departureTime` to incorporate time-dependent traffic data, and an `interpolate` flag for smooth linear interpolation between traffic time slices.

  ### Richer OpenAPI Metadata

  The OpenAPI specification has been updated with improved endpoint descriptions, contact information, and semantic tags for better discoverability and tooling support.
</Update>

<Update label="2025 Q3" description="v1.1.0">
  ## Batch Route Processing & Performance Enhancements

  ### 🚀 New Batch Route Endpoint

  Introducing the new `/route/batch` endpoint for processing multiple route requests efficiently in a single API call. This enables:

  * Reduced API overhead for multiple route calculations
  * Optimized network usage and faster processing

  ### ⚡ Performance Breakthroughs

  Major performance improvements across all routing services:

  * **Sub-50ms response times** for simple route calculations
  * **Sub-quadratic scaling** for large distance matrices - up to 3,836 table cells processed per millisecond
  * **Production-grade reliability** with 99.9% uptime SLA

  ### 🔄 Advanced Traffic Interpolation

  Enhanced time-dependent routing with decimal slice support:

  * **Granular traffic modeling** using decimal slices (e.g., 2.5, 4.7) for smooth transitions
  * **Linear interpolation** between time periods for more accurate travel time predictions
  * **Simplified architecture** reduces processing complexity while improving accuracy

  ### Demo page

  Added a demo page to showcase the new features and performance improvements.

  <Frame caption={ "Solvice Maps Demo Page"}>
    <img height="300" src="https://mintcdn.com/solvice/1Oz_OffF-EApdqyh/logo/demo.jpg?fit=max&auto=format&n=1Oz_OffF-EApdqyh&q=85&s=932250d211d538a5a75b2faf2d0d6add" data-path="logo/demo.jpg" />
  </Frame>

  ### 📊 Performance Scaling

  ```mermaid theme={null}
  %%{init: {'theme':'base', 'themeVariables': { 'primaryColor': '#0f62fe', 'primaryTextColor': '#000000', 'primaryBorderColor': '#0f62fe', 'lineColor': '#000000', 'secondaryColor': '#0f62fe', 'tertiaryColor': '#ffffff', 'background': 'transparent', 'mainBkg': 'transparent', 'secondaryBkg': 'transparent', 'cScale0': 'transparent', 'cScale1': 'transparent', 'cScale2': 'transparent', 'xyChart': {'backgroundColor': 'transparent', 'plotColorPalette': '#0f62fe, #0f62fe, #0f62fe'}}}}%%
  xychart-beta
      title "Table Operation Performance Scaling"
      x-axis ["10", "100", "1000"]
      y-axis "Throughput (cells/ms)" 0 --> 4000
      bar [17, 1060, 3836]
  ```

  *Performance demonstrates exceptional sub-quadratic scaling: as matrix size increases 100x, throughput increases 225x*
</Update>

<Update label="2025 Q2" description="v1.0.0">
  ## Introducing the `/cube` endpoint

  We all know about distance matrices (our `/table` endpoint), but Route Optimization systems require multiple slices throughout the day.
  Ideally one for every 5 minutes in the day in order to get the travel time as granular and accurately as possible.
  However, if you would want to solve a 1000-jobs VRP request, you would need 288 matrices of 1000x1000 elements.
  That would be quite cumbersome to first calculate and then secondly hold in memory during the solve.

  That is why we are introducing a /cube endpoint to fetch the entire 3-D matrix or what we call cube. 288 slices is too much but what if we can approximate it with a function?
  A polynomial that reduces the necessary slices. Read more in the [`/cube` introduction](cube/intro)

  <Frame caption={ "Increase granularity with the Travel Coefficient Cube"}>
    <img height="300" src="https://mintcdn.com/solvice/1Oz_OffF-EApdqyh/images/cube.png?fit=max&auto=format&n=1Oz_OffF-EApdqyh&q=85&s=f0b65b6bf6fddd3845343ea3fbb748fe" data-path="images/cube.png" />
  </Frame>
</Update>

<Update label="2025 Q1" description="v0.9.0">
  ## Predictive traffic integration

  <Frame caption={ "TomTom traffic integration"}>
    <img height="200" src="https://mintcdn.com/solvice/1Oz_OffF-EApdqyh/images/traffic.jpg?fit=max&auto=format&n=1Oz_OffF-EApdqyh&q=85&s=1161afdfaa0a0a2692e65cf1e90ca55c" data-path="images/traffic.jpg" />
  </Frame>

  Thanks to our partnership with TomTom, we can now provide predictive traffic information to our routing engine.
</Update>

<Update label="2024 Q4" description="Public Beta">
  ## Publicly launching Solvice Maps

  Solvice Maps is now publicly available since December 2024. We believe that it is one of the most powerful and fastest routing engines available.
  We're launching on OpenStreetMap data initially and will soon expand to other map data providers such as TomTom.

  Next to the routing engine, we also provide a tile server that can integrate with any map application and framework such as Leaflet, Mapbox GL JS, OpenLayers, etc.

  <Frame>
    <iframe width="100%" height="355" src="https://cdn.solvice.io/assets/examples/styles/white.html" />
  </Frame>
</Update>