Wisepath PoC series, Part 1 of 4. WiseCorp Engineering, November 2026.
Every minute of every day, somewhere in the world, someone asks the same question: what is the fastest way from here to there? A driver behind the wheel, a dispatcher planning a delivery round, an engineer routing wires inside a chip: the question never changes, only the map does. Wisepath answers it twice on purpose: once in software, once in hardware that was rebuilt for the job. This is the story of the first round.
In short:
- The project. Wisepath computes every route twice, at the same time: a PostgreSQL/PostGIS stack on CPU against a purpose-built Dijkstra kernel on an AWS F2 FPGA, over the real road network of Tunisia.
- The question. Routing gets hard in one specific place: the search frontier, the region of the graph a query must explore before it can prove its answer. Fixed hardware cannot adapt to it. Reconfigurable hardware can.
- The model. Wisepath is delivered as an on-demand proof of concept: for each paying customer, the PoC is instantiated for the duration of their exploration. Partners test it, see the PoC at work, judge it against their own use cases, needs and ambitions, then start working with us on what a real-world use case would be, and on the next step.
A graph under every business
Underneath every business that moves something (people, packages, signals, electricity) there is a graph. Its nodes are intersections, warehouses, routers, substations. Its edges are roads, routes, cables, lines. And on that graph, one question is asked millions of times a day: what is the shortest path?
Computer science has had a definitive answer to that question since 1959. Dijkstra’s algorithm [1] solves it in O((V + E) log V) with a binary heap, fast enough that most of the world stopped worrying about it decades ago.
But the theory hides a detail that matters enormously in practice. Before Dijkstra can certify that a path is the shortest, it must settle every vertex that could possibly be closer than the destination. That explored region has a name: the search frontier. And its size depends on the data, not on the algorithm. Ask for a route to the next neighborhood and the search touches a handful of vertices. Ask for a route across a country and the frontier can swallow the whole map.
That is where the performance battle really takes place, and it is a battle fixed hardware cannot enter, because fixed hardware cannot reshape itself for the frontier it meets. Wisepath was built to fight exactly there.
Two engines, one answer
Wisepath sends every route request to two engines in parallel and shows both answers side by side, each with its own measured latency.
The first engine is the reference the industry trusts: PostgreSQL 16 with PostGIS and pgRouting, running pgr_dijkstra on osmrouting_africa_tunisia.osm_2po_4pgr, the Tunisian road network converted from OpenStreetMap with osm2po [2], costs in kilometers, traversal undirected [3].
The second engine is the experiment: the same graph, uploaded once into the high-bandwidth memory of an AWS F2 instance, where a custom Dijkstra kernel, packaged as the PostgreSQL extension dijkstra_ext and exposed as the function pg_dijkstra_f, computes the identical query in reconfigurable silicon, driven through the XDMA driver and the AWS FPGA SDK.
The comparison is engineered to be honest. Both engines receive the same start and end vertices, return the same ordered sequence of nodes, and are timed on exactly the same work: the routing call itself. For the CPU, that is the wall-clock time of pgr_dijkstra. For the FPGA, it is the kernel window between AP_START and AP_DONE, reported by the extension itself. Everything else (snapping the points to the graph, rebuilding the geometry, moving data over PCIe) is deliberately excluded from the clock. One advisory lock serializes the FPGA, so a second concurrent query fails fast instead of waiting silently behind the first.
What the numbers say
The first campaign produced our favorite finding, and it had nothing to do with Dijkstra.
Every call to pg_dijkstra_f was paying a toll of roughly 510 ms before the kernel did any work: 510.76 ms on the first call, 511.12 ms on the second. The graph upload was fine; it ran once, as designed. The source told the real story: init_FPGA(), the routine that attaches to the FPGA and sets up memory mappings, was running on every single query. A flag named placed existed, was set, and was never read. One added line, if (placed) return;, and the toll disappeared.
| Before the fix | After the fix | |
|---|---|---|
| First call of a session | ~511 ms | ~524 ms, once (the physical attach) |
| Warm calls | ~511 ms each | 2.02 to 3.03 ms (mean 2.4 ms over 9 calls) |
Roughly two hundred times lower per call, from one line, because the cost was never in the algorithm. It sat at the boundary between software and hardware, where neither the database expert nor the hardware designer was looking. That is the hybrid thesis in a single sentence.
With the toll removed, the kernel itself could be measured, route by route.
FPGA kernel time per route (dijkstra:Timing).
| Route | Kernel time |
|---|---|
| 109403 to 110688 (3 nodes) | 1.07 ms |
| 109403 to 111000 | 68.2 ms |
| 109403 to 115000 | 545.1 ms |
| 109403 to 130000 | 97.1 ms |
| 30681 to 82716 (691 km, 1236 nodes) | 1113.6 ms |
Two things jump out. The time tracks the region visited, not the bytes moved: PCIe transfers per query are about 8 MB and 15 ms, outside the kernel window entirely. And the frontier is directional: two routes spanning similar distances can differ by more than a factor of five, because one pushes the search into dense territory while the other slips through. The kernel is frontier-bound, not bandwidth-bound.
On the longest route tested, 691 km across the country, the FPGA kernel completes in about 1.1 s, against 0.9 to 1.3 s for the CPU. Today, the two engines are level. We publish that exactly as measured. A PoC that hides its limits sells nothing; one that shows them tells a partner where the work is.
Where Wisepath fits
Roads are the demonstration. The computation is the product, and it fits anywhere a graph has to answer the same question at scale.
Mobility. ETA engines and ride-hailing platforms fire millions of path queries a day under latency budgets measured in milliseconds. Their graphs grow every week; hardware shaped for this workload changes what that volume costs.
Logistics. Fleet routing and last-mile delivery are giant shortest-path problems: which vehicle, which stops, which sequence. Every planning cycle recomputes thousands of paths, and the time saved is paid in fuel and hours.
Telecom. Backbones route on shortest paths; when a link dies, networks recompute them instantly. Millisecond routing budgets and hardware that adapts to the topology are a direct match.
Energy and cities. Power grids, water networks, fiber rollouts: physical graphs decades in the making, solved with the same mathematics as road navigation.
Chip design. Wire routing on silicon is among the largest shortest-path workloads that exist. In VLSI, software and hardware already meet at the frontier daily.
Public safety. For emergency services, the difference between a good route and the best route is measured in minutes that matter.
The model is built for this. A partner doesn’t read about Wisepath; they open it as an on-demand PoC, run their own questions against the engine, and judge it against their own graph. The use case that survives that judgment is the product we build together.
What’s next
The frontier is the target. Three weapons, in order: early termination, so the search stops the moment the destination is settled; a parallel frontier, so several vertices are settled per wave; and precomputed shortcuts (contraction hierarchies) that shrink the space the search has to explore at all. Each one is a step the fixed architectures cannot take.
An on-demand proof of concept
Wisepath is not a SaaS that stays awake between customers. It is a proof of concept instantiated on demand: for each paying customer, the PoC runs for the duration of their exploration, then is released. An auto-scaling group keeps the instance count at zero; a wake-up service starts the FPGA when an exploration begins; the graph loads once at boot; after a period of inactivity, the instance scales back to nothing. Compute exists only while a customer is exploring.
The invitation
This is part one of four: Wisepath is the first PoC in WiseCorp’s series on hybrid applications, where software and hardware are designed together rather than in sequence. The others will follow the same format: what we built, what it taught us, and how to test it yourself.
Open the app, choose two points on the Tunisian map, and watch both engines race on the same question. Then bring us your graph. Contact WiseCorp. The use case that comes out of that conversation is the product we want to build together.
Access the PoC
The product page on AWS Marketplace describes the offer. Subscribe, then open the PoC from the subscription page.
References
[1] E. W. Dijkstra, “A note on two problems in connexion with graphs”, Numerische Mathematik, vol. 1, 1959.
[2] osm2po, open-source routing converter. https://osm2po.de/
[3] pgRouting Project. https://pgrouting.org/