The shortest road from Shillong to Kolkata goes through Bangladesh

Vishal Meena — Fri, 09 Oct 2026 07:18:27 +0000

I keep a hobby site for Indian motorcycle tourers, rideplanner.in. It has 50 routes, from Manali to Leh to the Konkan coast to the North-East, and every fact on it carries its source and the day it was checked.

Last week I added "Riding from your city". You pick one of twelve cities, and every route tells you how far its start is by road, and how far it is back home from its end. That is 50 routes and 12 cities, there and back, or 984 distinct roads once shared ends are counted once.

I asked a road router for all 984. The answers looked fine until I read the one from Shillong to Kolkata: 662 km. The road a rider actually takes is 1,084 km.

The router was not wrong. The shortest road from Shillong to Kolkata runs straight through Bangladesh. Crossing it on a motorcycle needs a visa and papers for the bike, and nobody riding home from Meghalaya means to go that way.

It was not the only one. Delhi to Arunachal Pradesh went along Nepal's East-West Highway, and so did Guwahati to Manali. In the end, 229 of the 984 roads left India. This post is how I found them and kept them in, with nothing but Python's standard library.

Asking for the roads

The distances come from the OSRM demo server, which routes on OpenStreetMap data. It is free and asks to be used gently, so the script makes about one request a second and caches every answer in a JSON file. A second run asks nothing it has already asked.

def route(points):
    """The router's road through (lat, lon) points: km, hours, and the line as (lat, lon) pairs."""
    coords = ";".join(f"{p[1]:.5f},{p[0]:.5f}" for p in points)
    got = ask(f"https://router.project-osrm.org/route/v1/driving/{coords}?overview=simplified&geometries=geojson")
    time.sleep(1.1)
    ...
    rt = got["routes"][0]
    return rt["distance"] / 1000, rt["duration"] / 3600, [(p[1], p[0]) for p in rt["geometry"]["coordinates"]]

Two details matter later. The router takes any number of points, so a road "from A to B by way of C" is one request. And overview=simplified returns a line that stays within tens of metres of the road, which is plenty for checking a border.

Which roads leave India?

To know whether a road leaves India, I need the outlines of the countries it could cut through. Nominatim, OpenStreetMap's geocoder, returns a country's outline as GeoJSON, simplified to about a kilometre. I saved those of the neighbours once, into a file.

I never ask "is this point in India?". I only ask "is this point inside a neighbour?". The outlines are few and small, and the question is the one that matters.

The test is the classic ray-casting check. Draw a line from the point to the east and count how many edges of the outline it crosses. An odd count means the point is inside.

def _in_ring(pt, ring):
    lat, lon = pt
    inside = False
    j = len(ring) - 1
    for i in range(len(ring)):
        (ya, xa), (yb, xb) = ring[i], ring[j]
        if (ya > lat) != (yb > lat) and lon < (xb - xa) * (lat - ya) / ((yb - ya) or 1e-12) + xa:
            inside = not inside
        j = i
    return inside

A road line has thousands of points, so the script walks along it and tests one point every 2 km or so. It checks the outline's bounding box first, which rules out almost every point at almost no cost. A road with an end in a neighbour, such as the way home from Paro in Bhutan, may run through that country without counting.

def abroad(line, a, b):
    """The neighbours a road runs through, leaving out any its own two ends are in."""
    own = {country_at(a), country_at(b)}
    found, last = set(), None
    for p in line:
        if last is not None and hav(last, p) < 2:
            continue
        last = p
        cc = country_at(p, DEEP_KM)
        if cc and cc not in own:
            found.add(cc)
    return sorted(found)

Before asking the router again for any road, a cheaper test runs: does the straight line between the two ends come within a degree of a neighbour's box at all? Bengaluru to the Western Ghats never does, so it is never checked.

Keeping a road in India

A map app would offer you a different road. My script has only the router, so it does what a rider does: it adds a town to ride through.

I picked these towns by hand, from the roads riders actually take:

Siliguri. The only land link between the mainland and the North-East is a strip of India about 20 km wide at its narrowest, the Siliguri Corridor. Every road from Kolkata to Guwahati goes through it.
Purnia, Muzaffarpur, Gorakhpur, Bahraich, Lakhimpur and Pilibhit. India's own east-west road south of Nepal, for roads the router sends along Nepal's.
Pithoragarh and Champawat. Kumaon's road along the Kali river, which the router likes to swap for the Nepali bank.

For each road, the script finds where it first enters a neighbour. It picks the nearest town that has not been used yet and that serves that border, then asks the router again through that town. It repeats until the road stays in India, up to seven times.

def keep_in_india(a, b, line):
    vias, crossed = [], []
    for _ in range(7):
        found = entry(line, a, b)
        if not found:
            break
        cc, at = found
        crossed.append(cc)
        hold = hold_for(cc, at, a, b, vias)
        if hold is None:
            return None
        vias.append(hold)
        vias.sort(key=lambda v: hav(a, (v[1], v[2])))
        km, hrs, line = route([a, *[(la, lo) for _n, la, lo in vias], b])
    ...
    return {"km": round(km), "hours": round(hrs, 2), "via": [v[0] for v in vias], "shorter_abroad": sorted(set(crossed))}

Most roads need one town. 32 need two, often Siliguri and Purnia: a road from the North-East heading west first dodges Bangladesh, then Nepal. One needs four: Guwahati to Pithoragarh, by way of Purnia, Gorakhpur, Bahraich and Lakhimpur, 1,770 km. Each time the script adds a town, the router finds a new shortcut a little further along, so the loop has to run again.

My first list had Bareilly on it. It kept roads in India, but it pulled them onto a detour no one rides. Pilibhit and Lakhimpur sit on the road riders take, so they replaced it. A town that keeps a road in India is not enough. It has to be on the road a rider would choose.

The false alarms on the Kali river

The first full run flagged about a dozen roads in Kumaon, at the far end of Uttarakhand, as entering Nepal. They do not.

The road to Dharchula and beyond runs along the Kali river, and the river is the border. Villages such as Budhi and Tawaghat sit within a kilometre of it, on the Indian bank. The outlines I used are simplified to about a kilometre, so the simplified Nepal swallowed them.

The fix was to ask a second question: how far inside the outline is the point? A point counts as abroad only when it is at least 3 km inside.

DEEP_KM = 3

def _edge_km(pt, ring):
    """How far a point is from the nearest edge of a ring, in km, on a flat map around the point."""
    kx, ky = 111.32 * math.cos(math.radians(pt[0])), 110.57
    px, py = pt[1] * kx, pt[0] * ky
    best = float("inf")
    for i in range(len(ring) - 1):
        ax, ay = ring[i][1] * kx, ring[i][0] * ky
        bx, by = ring[i + 1][1] * kx, ring[i + 1][0] * ky
        dx, dy = bx - ax, by - ay
        f = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / ((dx * dx + dy * dy) or 1e-12)))
        best = min(best, math.hypot(px - (ax + f * dx), py - (ay + f * dy)))
    return best

Over a few hundred kilometres, treating the earth as flat is fine. A degree of longitude is 111 km times the cosine of the latitude, and a degree of latitude is about 110.6 km. The distance to each edge is the usual distance from a point to a segment.

Three kilometres is safe both ways. It is more than the outline's error, and the roads that really cross run tens of kilometres inside Nepal or Bangladesh. With the deeper test, 11 Kumaon roads went back to their direct line, and nothing real was missed.

The boring problems took longest

Getting the answers out of the router took an afternoon and an evening, and most of that was not about borders.

The laptop slept. A request open at that moment never returned, and the run sat there. Every connection now gives up after 90 seconds, and the long runs go under caffeinate -i, which keeps the Mac awake.
IPv6 hung. For half an hour at a time, my IPv6 route to the router stalled mid-connection, while IPv4 answered in under a second. Python has no switch for this, so the script wraps the address lookup:

socket.setdefaulttimeout(90)
_getaddrinfo = socket.getaddrinfo
socket.getaddrinfo = lambda host, port, family=0, *a, **k: _getaddrinfo(host, port, socket.AF_INET, *a, **k)

Two services, two paces. The router and the geocoder, which names a few towns along each road, each want about a request a second. They run as two separate processes that share nothing but the cache files, so neither waits for the other. Every save writes a temporary file and renames it over the old one, so a run killed halfway never leaves a broken file.
Running the check again. The border test changed more than once, so every road carries a checked mark saying which version of the test cleared it. A new version re-checks only what it has not seen.

What riders see

When a distance goes by an Indian town, the page says so: "By way of Siliguri, to stay in India: the shortest road crosses a border." It does not say which way is better, or how many days a leg takes. Those are the rider's decisions.

The numbers, in the end:

984 roads, of which 229 go by an Indian town: 151 to stay out of Nepal, 51 out of Bangladesh, and 27 out of both.
Riders from Guwahati see it most: 75 of their 95 distances need a detour.
Shillong to Kolkata goes from 662 km to 1,084. Guwahati to Manali goes from 2,255 km along Nepal's highway to 2,349 km by way of Purnia.
No distance on the site crosses a border, except to the two routes that are in Nepal and Bhutan themselves.

Why no GIS library?

Shapely or GeoPandas would have done the point-in-polygon test in one line. I kept to the standard library on purpose. Anyone who wants to fix a route's data can run every script in the repository with plain Python 3, and nothing to install. The whole border check is under 200 lines, comments included.

The code

Meel is open source: MIT for the code, and the data keeps its sources' licences. The script is data/tools/approaches.py, and the result is one JSON file the site reads.

If you would like to help, there are good first issues, including one to add a city riders set out from. If you ride, the site is at rideplanner.in. Every fact there has a "Still true" button, and it needs no account.

Map data ¬© OpenStreetMap contributors, under the Open Database Licence. Roads from OSRM, outlines and place names from Nominatim.

DEV Community: Vishal Meena