OpenStreetMap Blogs

I would like to ask if it would be possible to change the color of the monastery area marking to something other than gray, because it blends in quite a bit on the map and is therefore difficult to read. I know that no one can change it, but I would like to see it resolved somehow, for example with a darker shade of gray. Thank you for all the comments and feedback.

منزل علي سفاع

I made Walkably, a free walkability map for 31 European countries.

Streets, paths and places come from OpenStreetMap contributors (ODbL). Every street gets a score from 0 to 100.

How the score uses OpenStreetMap

• Reach is 60% of the score: the real walk on streets and paths to eight daily needs, such as groceries, parks and public transport. A shorter walk scores more, and the second and third option nearby count too.
• Street quality is 40%: traffic, busy roads nearby, summer shade and slope.

Census checks

Where more people walk to work, the score is higher. In five places I compared the order of neighbourhoods by Walkably score with the share who walk to work in the census (1 means the same order, 0 means no relation):

• France: 0.73
• Northern Ireland: 0.70
• Ireland: 0.69
• England and Wales: 0.62
• Scotland: 0.46

Where it falls short

• City against city, the score does not match the share who walk to work (0.00). The share who walk or take public transport matches much better (0.60).
• Summer shade is an estimate. It does not match a study of tree cover over streets in 43 European city centres.
• In Barcelona’s Eixample, our street quality does not match a street audit that rates benches, bike lanes and graffiti, which we do not measure.

Every check and its result: https://walkably.org/accuracy

What you can use

Berlin, Hamburg, Munich, Vienna and Rome rank their districts, each with a CSV table to download under the ODbL.

If a shop or path is missing in OpenStreetMap, please map it there. If a score still looks wrong, use the “Report a wrong score” button on the map.

I lost my wife because of cancer on 22 September. Half of my soul and motivation also lost with her..

منزل علي سفاع

Hello everyone,

I have been adding and fixing temples in Surat, Gujarat. Many temples and community halls are missing on the map, or have wrong or incomplete details. I want to make them easier to find.

What I did

Added new temples in [Surat] Fixed wrong temple names Added names in Hindi and Gujarati so people can search in their own language Added community halls used for religious ceremonies

Tags I used

amenity=place_of_worship religion=hindu building=temple name=* name:hi=* name:gu=*

Where I need help

Some places are only open during festivals, like Navratri garba grounds and pandals. I don’t know the best way to tag them.

My questions

How should I tag temporary festival venues? Are there other mappers in Gujarat I can work with?

Disclosure: I work with Pandits Near Me a service that helps people find and book pandits for pujas. I am mapping these places to make local information more accurate.

Thank you for reading. Any feedback or advice is welcome!

Gent heeft een vrij goede dekking van gebouwen en adressen, maar ik kom toch nog af en toe ontbrekende adressen tegen. Hieronder een samenvatting van een systematischere aanpak om uit te zoeken waar OSM nog adressen uit de officiële data mist, vooral als geheugensteuntje voor mezelf.

Om het werk enigszins behapbaar te houden, beperk ik me in dit geval tot adressen in de postcode 9031 van Drongen.

Begin met een overpass turbo query:

area[description="9031 Drongen"]->.a;
(nwr(area.a)["addr:housenumber"];);
out;

en download de “raw OSM data” export. Sla op als .osm bestand, bijvoorbeeld 2026-10-25_9031.osm.

Met osmconvert, bv. als ./xml-to-csv.py 2026-10-25_9031.osm, krijg je een 2026-10-25_9031.csv bestand met alleen de relevante informatie.

#!/usr/bin/env python3

import os
import subprocess
import sys

def main(i: str):
    print(f"Converting {i}")
    if not i.endswith(".osm"):
        raise Exception(f"Expected file name ending with '.osm', got {i}")
    if not os.path.exists(i):
        raise Exception(f"Did not find file {i}")
    base = i[:-4]
    fn_out = f"{base}.csv"
    args = [
        "osmconvert",
        f"-o={fn_out}",
        "--csv-headline",
        "--out-csv",
        '--csv="@id addr:street addr:housenumber addr:unit"',
        f"{i}",
    ]
    print(" ".join(args))
    # subprocess.check_call(args)
    subprocess.check_call(" ".join(args), shell=True)

if __name__ == "__main__":
    main(*sys.argv[1:])

Nu hebben we de officiële data nodig. Het register is te downloaden via vlaanderen.be, na in te loggen met e-ID. Vul in:

• Type versnijding: Gemeente
• Buffer: Geen buffer
• Gemeente(n): Gent

Het duurt enige tijd voor het bestand klaar is; je geeft je e-mailadres in en krijgt bericht wanneer het kan gedownload worden. Het gaat om een zip-bestand, in dit geval Gebouwen_en_adressenregister_20261025_44021_Shapefile_LB08.zip, waarin 44021 de NIS-code van Gent is. Het relevante bestand is Gebouwen_en_adressenregister_20261025_44021_Shapefile_LB08/Shapefile/Adres44021.shp.

Dit bestand bevat de adressen van heel Gent. Ik gebruik QGIS om me te beperken tot Drongen. Dit kan wellicht op een andere en meer efficiënte manier, maar het is voor het vervolg nog zo nuttig om de data open te hebben.

Open het bestand in QGIS; in het paneel “Layers” staat de layer “Adres44021” met heel Gent. Klik met de rechtermuisknop op de layer, klik “Filter”, vul als uitdrukking "postcode"='9031' AND "status" = 'InGebruik' in en druk “OK”. Klik opnieuw met de rechtermuisknop op de layer, volg “Export”, klik “Save Features As”, kies de bestandsnaam (bv. 2026-10-25_GRB_9031.csv) en druk “OK”.

Nu heb je beide datasets als CSV en kan je de data gaan vergelijken met een vrij rudimentair script:

#!/usr/bin/env python3

import csv
from collections import defaultdict
import re
import sys

rgx = re.compile(r"\s*([0-9]+)([A-Z]+)\s*")

def interpolate(street, fr, to):
    try:
        f = int(fr)
        t = int(to)
        for x in range(f, t + 1):
            yield str(x)
    except ValueError:
        frparsed = rgx.match(fr)
        toparsed = rgx.match(to)
        if not frparsed or not toparsed:
            print(f"Can't interpolate {street} {fr}-{to}")
            return
        fn, fl = frparsed.groups()
        tn, tl = toparsed.groups()
        if fn != tn:
            print(f"Can't interpolate {street} {fr}-{to}")
            return
        for suffix in [chr(i) for i in range(ord(fl), ord(tl) + 1)]:
            yield fn + suffix

def housenumbers(row):
    street = row["addr:street"].lower()
    unit = row["addr:unit"]
    nr = row["addr:housenumber"]
    if unit:
        if ";" in nr or "-" in nr:
            print(f"ERROR {row}")
        else:
            yield nr + unit
        return
    nrs = nr.split(";")
    for n in nrs:
        nrs2 = n.split("-")
        if len(nrs2) == 1:
            yield nrs2[0]
        elif len(nrs2) == 2:
            yield from interpolate(street, *nrs2)
        else:
            print(f"ERROR {row}")


def readosm(osm: str, addresses: defaultdict[str, set[str]]):
    with open(osm, newline='') as csvfile:
        reader = csv.DictReader(csvfile, delimiter='\t')
        for row in reader:
            try:
                street = row["addr:street"].lower()
                addresses[street].update(housenumbers(row))
            except Exception as e:
                print(f"ERROR {row}")
                raise e

def main(crab: str, osm: str):
    addresses: defaultdict[str, set[str]] = defaultdict(set)
    readosm(osm, addresses)
    with open(crab) as csvfile:
        reader = csv.DictReader(csvfile, delimiter=',')
        for row in reader:
            status = row["status"]
            if status != "InGebruik":
                continue
            street = row["straatnm"]
            nr = row["huisnr"]
            if nr not in addresses[street.lower()]:
                print(f"{street} {nr}")

if __name__ == "__main__":
    main(*sys.argv[1:])

Bijvoorbeeld als ./process.py 2026-10-25_GRB_9031.csv 2026-10-25_9031.csv | sort | uniq.

Interpolatie van huisnummers wordt ondersteund tussen twee getallen (12-18, waarbij ook de oneven nummers worden meegerekend) of tussen twee huisnummers die bestaan uit hetzelfde getal met een verschillende letter-suffix (12A-12D). Andere gevallen (10-10A of 12-18C) worden niet ondersteund en krijgen een “Can’t interpolate” foutmelding en zullen ook als ontbrekende adressen voorkomen. Deze gevallen worden best op voorhand opgeruimd tot een ondubbelzinnige waarde.

Hetzelfde adres kan verschillende keren voorkomen in de officiële data (bijvoorbeeld met verschillende busnummers), wat wordt opgelost door de deduplicatie met | sort | uniq.

Adressen die (foutief) in OSM opgenomen zijn met een addr:unit tag (bijvoorbeeld addr:housenumber=1 addr:unit=A i.p.v. addr:housenumber=1A) worden in dit script wel gehercombineerd. Deze corrigeren in OSM is een aparte taak.

Merk op dat de controle maar in één richting gaat: ze maakt je attent op adressen in het register die ontbreken in OSM. Adressen die bestaan in OSM maar niet in het register worden niet opgemerkt.

Conclusie voor Drongen: op ca. 6600 adressen in het officiële adressenregister waren er een 15-tal OSM-gebouwen met dubbelzinnige addr:housenumber en ruim 300 ontbrekende adressen. Daarvan heb ik er al enkele tientallen aangevuld; meer is voor een ander moment.

De ontbrekende adressen hadden verschillende oorzaken:

• gebouwen met meerdere adressen waarvan slechts één getagd is;
• percelen die wel al een adres hebben, maar nog niet bebouwd zijn;
• een enkele woning die verdwenen is door de verbreding van de spoorweg;
• typos (nr 23 ipv 13, of twee nummers 26 naast elkaar i.p.v. 26 en 28);
• correct huisnummer maar verkeerde straatnaam.

Chcel by som poprosiť, či by sa nedalo, aby farba označenia kláštorného areálu nebola sivá, pretože dosť splýva na mape a je tým pádom zle čitateľná. Viem že to asi nikto nebude vedieť zmeniť, ale chcel aby sa to nejakým spôsobom vyriešilo, napr.: dať tmavší odtieň sivej. Za všetky pripomienky a prípadnú ďakujem.

Hello all,

I’d like to introduce PillarPoint, a free and open source Android app for people who find, visit and record British triangulation (trig) points and Ordnance Survey bench marks.

What it does

• Shows all 26,976 trig points from TrigpointingUK and over 265,000 bench marks from the Bench Mark Database on an OpenStreetMap base map, with a “nearest to me” list
• Works offline after the first download. Plenty of trig points are well out of mobile signal
• Lets you log a visit with a condition report, notes, photos and an optional GPX track. If you sign in, visits sync to your TrigpointingUK and Bench Mark Database accounts, and photos upload to TrigpointingUK
• No adverts, no analytics and no tracking

Where OpenStreetMap comes in

For each trig point, the app checks whether OSM already has a matching survey point. It also tells you if the OSM node is some distance from where the station is recorded.

If a trig point looks to be missing from OSM, you can report it with an OSM note or open the iD editor. Both only work when you’re actually standing within 50 metres of it. That’s deliberate. TrigpointingUK and Bench Mark Database positions come from Ordnance Survey data, which is Crown copyright and can’t be copied into OSM. So the app never uses them. A note is always placed at your own GPS position, which is your own observation and fine to share. The app shows how good your GPS fix is before you file, so you can wait for a better one. The app explains this itself where you file a note, as well as in its privacy notice.

A “field notes queue” keeps a list of visited trig points that seem to be missing from OSM, so you can deal with them later or when you’re next back on site.

How it was made

In the open: I’m not a professional Android developer, and the app has been built with a lot of help from Claude, an AI assistant. I test every release on my own phone and out in the field, and the code is all public for anyone to look over.

Trying it

It’s Android only for now. The latest signed APK (v0.8.18) is on the releases page: https://codeberg.org/pillarpoint/pillarpoint/releases

It’s still early, so please send bug reports, ideas and “this is wrong” comments to the issue tracker, or reply here: https://codeberg.org/pillarpoint/pillarpoint/issues

Thanks for reading, Chris

OpenStreetMap is a collaborative mapping project that allows people around the world to explore maps and contribute geographic information. Community members work together to improve map data and make geographic information more accessible.

Learn more by visiting Exploring OpenStreetMap and Its Mapping Community.

If you have ever typed an address into OsmAnd and got a street in another town — or nothing at all — you are not alone. Search has been the most common complaint we hear, and in our 2026 survey it came up again and again in every language. So this year we did not patch it once more. We built a new search engine from scratch, and it comes to everyone with OsmAnd 5.5. If you don't want to wait, it is already in our nightly builds.

The video above tells the whole story in 23 minutes. Below is the short version, with a few interactive demos so you can play with the same ideas the new engine uses.

What Changes for You​

• Addresses typed your way. Unter den Linden 10 or 10 Unter den Linden, S Mountain Blvd for South Mountain Boulevard, a postcode or a state instead of a town.
• Typos corrected. Misspell a word and search offers the right one: leopoldstrase 10 → Leopoldstraße 10, mnuc → München.
• Suggestions as you type. Start a word and search offers the most common words that continue it — tap one instead of typing the rest.
• Public services by the name people use. DMV finds motor vehicle offices and NHS finds NHS clinics, even when the map lists the organisation only as the operator.
• Categories in more words and languages. Categories match common synonyms and work in your language, in English, and in the local language: with the app in English, both school and Schule find schools in Germany.
• Places next to places. Fuel McDonald's finds gas stations with a McDonald's nearby; Shell on a named street; two streets that cross.
• Faster and measured. The search itself is about five times faster, and every change now runs against 137,000 real searches in 28 test sets — 99.5% of them are found.

Why Is This So Hard Offline?​

Google can afford to be clever: every query goes to a server that has learned from billions of searches, corrections, and taps. OsmAnd has no server. Everything happens on your phone, inside the map files you downloaded — so the phone itself has to work out what you meant.

And addresses have no grammar book. Every country writes them its own way, and people mix the parts in any order. The same line of text can mean two different places:

First, Measure​

For years every release fixed some search bugs, and every year 50 to 90 new ones came in. Users told us almost nothing works; we could not reproduce a single bug ourselves. So in 2025 we stopped guessing and built a test bench: take thousands of real addresses from the map, type each one the way a person would, and count how many are found.

The first honest number was about 80%. Every user report with a real address became another test — and the bench, not our feeling, started deciding what is fixed.

The Old Way: a Librarian​

The old search worked like a librarian: find the town, walk along its shelf of streets, open the street, find the house. It works well in a small town. It works much worse when the town is London — one shelf with 56,266 streets — or when there is no town at all and a single word can be a village, a street, or a hospital. Try it:

Every address that broke got its own patch: townships, word order, abbreviations. Each patch fixed one address and broke another, and together they became slow and fragile. One user with eighty maps installed waited more than two minutes for the right result.

The New Idea: Put the Words on the Map​

We are searching a map, after all. So instead of walking shelves, the new engine lights up every word of the query on the map, and looks for the places where the lights meet. A street and its town meet because their areas overlap; a McDonald's and a gas station meet because they stand next to each other. Since June 2026 every street and every town in OsmAnd maps carries its own area for exactly this.

Here are the real objects the engine finds in Portugal for one long query. Pick the words and watch the map:

The Zipper​

Comparing every object of one word with every object of another would take hundreds of millions of checks — more than half a minute for a single search. The trick is the same one every web map uses: tiles. The world is cut into four squares, each of them into four again, and so on, and every tile gets a number along a Z-shaped curve. Two tiles never overlap partially — they are either apart or one sits inside the other.

So each word becomes a sorted list of tile numbers, and two words are joined by walking both lists at once, like a zipper. Pairs that can't meet are never looked at:

An advanced version of the zipper jumps between tile levels — a town is a big tile, a street a small one — and skips whole regions where the other word has nothing. Half a minute became 50 milliseconds.

Tetris With Words​

Long queries, like a crossing of two streets, add one more twist. Each object covers only some of the words, so the answer is a set of pieces that covers every word exactly once — and also meets on the map. It is a classic hard problem, the same family as Sudoku. The engine plays it like Tetris: pieces dock into a row, every docking is checked on the map, and a row that drops to zero disappears together with everything that could have been built on it.

This is the engine's real trace for Travessa de Santo António, Rua Joaquim Ribeiro de Carvalho, Portugal:

Where We Are Now​

The new engine went from its first test run in July 2026 to beating the old search two days later, and kept climbing. Today 99.5% of the 137,000 test searches are found. In Pennsylvania, where we started, the addresses we could not find went from 206 to 40 to 7 — and those last seven are broken in OpenStreetMap itself.

It also handles queries the old search never could, like a McDonald's next to a gas station.

Not everything is solved. Havana's Calle L, between 23 and 25 has no house number, only the two streets around it, and we still can't find it. Ranking, typos, and common words each deserve a story of their own.

Try It and Help​

The new search comes with OsmAnd 5.5. You can try it today in our nightly builds, and as always the code is on GitHub. How to use search is described in the Search documentation.

• Tell us what you typed. When search can't find something, send us the exact query to support@osmand.net or open an issue on GitHub — every miss becomes a test.
• Help the map. A street without a name can't be found, and streets inside a town without a boundary may be missed. Add names and draw boundaries in OpenStreetMap.

The video has subtitles in 7 languages and dubbed audio in German, French, Italian, and Spanish.

We appreciate your interest in us and thank you for taking the time to read this article. Join us on social media to keep up to date with the latest news and share your experiences. Your opinion is important to us.

• Follow:

  Follow OsmAnd on Facebook, TikTok, X (Twitter), Reddit, and Instagram!

• Join:

  Join us at our groups of Telegram (OsmAnd News channel), (EN), (IT), (FR), (DE), (UA), (ES), (BR-PT), (PL), (AR), (TR).

• Get:  

  

  
  

I used to play Ingress. For those who haven’t heard of it, you have probably heard of its younger (more popular) sibling, Pokémon Go, especially if you had to deal with map vandalism from its playerbase. When I acquired my first smartphone, mobile games were still a new thing, and they were mostly full of gimmicks. They never captured the same level of immersion that you could experience when playing a computer or home console game. But when a friend introduced me to Ingress, it was unique, and I was instantly hooked. The storytelling turned me into an “agent” and my phone into an “XM scanner,” just like the cool sci-fi stuff I’d seen in movies. But it was more than just a gimmick, because going somewhere in the real world and coordinating with other players was an integral part of the game. I met a lot of people because of Ingress, and travelled to some amazing places I wouldn’t have otherwise. But as with any game you spend hours and hours playing, I eventually got burned out.

A few years ago, I remember hearing about StreetComplete, a gamified way to contribute to OpenStreetMap by solving quests. It sounded like a more productive way to fill the time I had been using for Ingress, while still scratching the itch to explore. As of this writing, the iOS StreetComplete app has only been published for a week, so needless to say, I couldn’t use it on my iPhone back then. When discussion of ALPRs came up in the United States more recently, I saw OpenStreetMap mentioned again, and this time I had an Android phone. I downloaded StreetComplete, and have been contributing as a hobby on and off ever since.