[!warning]
Vela is in beta, so you may run into bugs. If you do, open an issue and fill out the
template. Nightlies and canary builds are newer still and less tested than the weekly stable.
A degoogled maps & navigation client for Android - what NewPipe is to YouTube,
for Google Maps. The map itself is open data: open vector tiles for the
basemap, and Vela data for the places on it - Overture Maps and
AllThePlaces, positioned with OpenStreetMap, baked into tiles in this repo and
streamed from its releases - so browsing around never asks Google anything.
Routes come from the open OSRM router. Search, tap a place or ask for a route
and the device itself scrapes Google's public web endpoints (per-user, no
backend) for the things only Google does well: search, hours, reviews and
photos, and traffic-aware ETAs. Built to run on GrapheneOS and other no-GMS
ROMs.
What reaches Google, by default
It is not a Google Maps wrapper. The map is a native Android app drawing open vector tiles
(Jetpack Compose and MapLibre) - no Google SDK, no Play Services, no API key, nothing to sign in
to. It looks like Google Maps because that is the point; underneath, almost none of it is.
| What you do |
What reaches Google |
| Pan, zoom, browse the map |
Nothing. Tiles from OpenFreeMap, streets and labels from OpenStreetMap |
| The places drawn on the map |
Nothing, by default. Open data baked in this repo: Overture Maps and AllThePlaces, positioned with OpenStreetMap |
| Drop a pin, tap a house number |
Nothing. OpenStreetMap's Nominatim names the spot |
| Read a departure board |
Nothing, for the stops Vela draws from open transit data: the board comes from Transitous. Where Transitous has no coverage, Vela falls back to the stop's Google page |
| Ask for directions |
The traffic, and only the traffic. The route itself is computed by open OSRM, or on the phone from an OsmAnd-format region file (Google's own route only if the open router is down); Google is asked anonymously for the live ETA on top of it, and every couple of minutes while you drive, which Settings → Navigation turns off. For a walk Google is asked once for its route, used only when it is much shorter |
| Type a search |
Your text, anonymously, like a logged-out browser. Typing sends Google's own autocomplete each time you pause; submitting sends a Google search. Text that starts with a house number also goes to the open Photon geocoder |
| Tap a place |
An anonymous lookup of that place - no account, no app key. Hours, reviews and photos are the things only Google does well. Settings → Places can stop the lookup for places tapped on the map |
| Everything you save |
Nothing, ever. No account, no Vela backend, no Vela telemetry; saved places, history and settings stay on the phone |
Download a region and it keeps working with no network: the map, search, routing and
turn-by-turn navigation. Offline, or with Settings → Privacy → Use Vela without Google, the
answer becomes nothing at all. A few things only a real browser engine gets, the first page of
a place's reviews among them, are read from a Google page in an offscreen WebView, anonymously;
the full list is in PRIVACY.md.
The full comparison against the Google Maps app and Google Maps web is below, and
the per-request detail is in PRIVACY.md.
Screenshots
| Navigation |
Map & search |
Place details |
Directions |
Search results |
 |
 |
 |
 |
 |
| Public transit |
Departure board |
Stops on the line |
Light theme - map |
Light theme - place |
 |
 |
 |
 |
 |
Turn-by-turn with lane guidance, route shields and the speedometer; the keyless
OpenFreeMap basemap wearing Google's own sampled colors and Google Sans Flex labels, with
rated POI icons and the tiered dots; live place data; the directions panel with
alternates, traffic in plain words and the avoid toggles; live departure boards
with a tap-through stop list for every route; and the in-app light/dark themes
(decoupled from the OS).
Install
Obtainium auto-tracks the
weekly stable release. Turn on "include prereleases" and you get the
nightly channel instead.
The F-Droid badge is
Vela's own repository, not the f-droid.org catalog - add
https://pimpinpumpkin.github.io/Vela/repo to any F-Droid client and it serves
the same signed APKs, weekly stable by default (fingerprint and nightly-channel
setup in FDROID.md). Or grab an APK straight from
Releases.
Check you got the real thing
Every Vela APK, from any channel, is signed with the same key. Its certificate
fingerprint is:
SHA-256 29:93:8B:48:58:06:3E:42:E6:77:FF:95:C9:01:CD:48:24:8A:7F:03:2A:3A:E8:5F:9B:9E:56:17:56:8B:0D:36
Check a downloaded file against it before installing:
apksigner verify --print-certs vela-maps-*.apk
On the phone, App Verifier checks
the same thing. It wants the package name on the first line and the fingerprint
on the second, so paste this block, not the line above:
app.vela
29:93:8B:48:58:06:3E:42:E6:77:FF:95:C9:01:CD:48:24:8A:7F:03:2A:3A:E8:5F:9B:9E:56:17:56:8B:0D:36
Android enforces this for you after the first install: an update signed with a
different key is refused, so a build that installs over your existing Vela came
from the same place this one did.
This is the certificate the app is signed with, and it stays the same across
releases. It is not a checksum of a particular APK, and it is not the same as
the F-Droid repo fingerprint in FDROID.md, which signs the repo
index rather than the app.
There's also a one-page tour at
pimpinpumpkin.github.io/Vela, and every doc in this
repository (the FAQ, the book, the full specification) is published there as a searchable site at
pimpinpumpkin.github.io/Vela/docs.
What you get
Live traffic, straight from Google. Vela reads the same real-time traffic
Google Maps shows, so ETAs are traffic-aware, the fastest route leads the list,
and every option says light, moderate or heavy traffic in plain words next to
its green/amber/red time. Turn-by-turn navigation rides on it: lane diagrams,
exit shields, a speedometer with the posted limit, and automatic reroutes when
a jam builds ahead.
The places on the map are open data; Google fills in the details. Every pin,
dot and label you pan past is Vela data - Overture Maps and AllThePlaces,
positioned with OpenStreetMap, baked into map tiles in this repo and streamed
from its releases, and carried offline with a downloaded region. Browsing sends
Google nothing. Tapping a place is what asks Google, and it answers with what
open data has no equivalent of: hours with holidays included, reviews you can
search, photo galleries, busy times, phone and website, with a warning if a
place would be closed when you arrive. Settings → Places → "Places come from"
switches the map between Vela data (the default), Both, or Google, and a
separate toggle stops even a tapped place from being looked up. The
FAQ has the per-feature breakdown of what uses what.
Zero Google on your phone, and almost zero in your life. No Play Services,
no account, no app key, no ads, no GCM/FCM, no Play Integrity. Google never sees
your map browsing, your saved places, or your account; your GPS trail stays on the
phone. A position reaches Google only in a few specific requests: a route from your
location, a search that ranks places near you first, and the anonymous re-route and
traffic checks while you navigate. The full breakdown is in the Privacy
section below.
Flock cameras, on the map. Mapped ALPR surveillance cameras (the
community DeFlock project's OpenStreetMap data) draw out of the box, and the
optional Settings → Navigation → Avoid surveillance cameras counts the cameras on
each route (only the ones pointed along your road) and quietly picks a
lower-camera option when the detour is small. Two more opt-ins in the same
place give you a heads-up card or a spoken "License plate camera ahead" as you
approach one while navigating.
The dataset lives on your phone and refreshes itself weekly.
Vela Voice. Spoken turn-by-turn from a neural voice that runs entirely on
your phone, and a mic that transcribes your search on-device too. Nothing you
say ever touches a cloud speech service.
🔊 Hear it - the actual in-app voice at the default pace:
https://github.com/user-attachments/assets/17f246e4-51c8-4d01-998b-dcd7f29dc15f
Parking memory. Tap P when you park, tap the pin later for walking
directions back, long-press for your parking history.
Material You theming, if you want it. An optional toggle tints Vela's
chrome with your wallpaper colors (Android 12+); off by default, and the map
itself stays clean either way.
Offline maps and routing. Download a state or country once and its maps,
turn-by-turn routing, and every place in it stay searchable with no signal -
typed street addresses included.
Live gas prices. Search for gas and every station's current price is right
on its map marker, in the result list, and on the place page.
Live public transit. Departure boards and station-by-station stop timelines
come from open GTFS feeds (the schedules and realtime updates transit agencies
publish, served by the community Transitous project), supplemented with Google
for traffic-aware transit directions and for boards where the open feeds have
no coverage. Tap a stop for live times, tap a route for every stop it makes.
Satellite imagery map: See the world from a birds-eye view, powered by Esri.
Street View: real panoramas in-app, keyless - open on a place, look around, walk the street with arrows, and go back in time through older captures; half-screen over the live map or full screen.
Lists: the bookmark button next to the category chips opens Your lists.
Create one there, or add any place from its page (⋮ → Save to list), with a note
per place. Lists back up to a file from Settings.
Import a Google Maps list: paste a maps.app.goo.gl share link into the
search bar. The list's places show up as results with the owner's notes; tap
Save list to keep a local copy.
Fixes itself when Google moves things. The scraping recipes live in a signed
config the app checks at launch - when Google shifts a field or an endpoint, a
repair ships to every install in minutes, no update needed. The same channel can
push a heads-up notice ("search is down, fix coming") straight onto the map. See SPEC.md sections 3 and 11 for details.
Say it or type it. "Take me home", "get me to work", "navigate to the station",
"Davis to San Francisco", "nearest pharmacy", "what's my ETA": the search box understands
those as actions, spoken through the mic or typed, in every language the app speaks, with
English understood everywhere too, and a slip in the command words ("navigat to the
station") still lands. Dictation is a small on-device speech model; the understanding is
plain rules on the phone. Neither step leaves it; only the search or route that comes out
of them does.
The rest. Android Auto, 15 languages,
in-app light/dark, full D-pad operation for keypad phones, place lists, and a
built-in updater with weekly-stable or nightly channels.
The complete running feature list lives in FEATURES.md.
Common questions
Where the places on the map come from, what each feature uses, and how to run Vela with no
Google contact at all: docs/FAQ.md. The short version is that the map and
its businesses are open data by default, and Google answers searches, place pages and live
traffic.
Why a degoogled app uses Google
A phone without Google Play Services cannot run Google Maps, and the open map
datasets fall well short on search, reviews, hours, and live traffic. So for those,
Vela is a client of Google's public web endpoints. It asks them the same way a
logged-out browser does, from each user's own phone, with no account, no shared API
key, and no server in the middle. NewPipe does the same for YouTube. There are no
ads, and your search history, saved places, and settings stay on the phone. If you
run GrapheneOS or another no-GMS ROM, this gets you working maps back.
The map itself, the streets, the labels, and house numbers come from OpenStreetMap (in much of the US the house numbers come from OpenAddresses instead), and routes come from the open OSRM router. Google is only used for place details, search, and live traffic, plus extras you open yourself such as Street View and transit directions. So street names and house numbers can differ from what Google Maps shows, and how much detail you see offline depends on how well OpenStreetMap covers your area. I'm thinking of ways to improve OSM and fill the gaps in the data. Stay tuned.
Privacy
There is no Vela backend, no account, and no Vela telemetry. Vela fetches from Google
directly from your phone like a logged-out browser - Google sees your IP, query, and
map area, but not a Google account or any app key, much like using
google.com/maps in an incognito window. Google does keep its own logged-out session
cookie; Vela starts a new one every week by default (Settings → Privacy → Google
session: weekly, daily, or every launch, plus a button to start one now). Your saved
places, history, and settings never leave the device. Read the full breakdown of
exactly what each service receives → PRIVACY.md.
The short version: Google shrinks from knowing who you are and everywhere you go to
occasionally answering an anonymous question. With the default place source your map
browsing never reaches Google at all, and your GPS trace is never uploaded anywhere.
While you're actively navigating, Vela does ask Google for fresh traffic from your current
position every couple of minutes - that's what powers the faster-route offers and the live
arrival time - and that re-check can be turned off in Settings → Navigation ("Live
traffic re-checks while navigating"); off-course re-routes remain, since turn-by-turn can't
work without them.
| What Google gets |
Google Maps app |
Google Maps web |
Vela |
| Tied to your Google account |
Yes, always signed in |
Yes unless incognito |
Never - there is no login |
| A persistent device identifier |
Yes (device + ad IDs via Play Services) |
Browser cookies |
No account, no app key; a logged-out Google session cookie that Vela replaces weekly by default, and an IP like any website visitor |
| Your precise GPS position |
Continuously while open, plus Location History if enabled |
While the tab is open |
Never while browsing - position stays on the phone. Searches send the map area you are looking at and, to rank places near you first, can ask about a small area around you; a route from your location sends that point as the start. While navigating, anonymous re-routes and the optional live-traffic re-check send your current position (toggleable in Settings → Navigation) |
| Every pan and zoom of the map |
Yes - their servers render the map |
Yes |
No, by default - map tiles come from OpenFreeMap and the places on them from Vela's own data, so Google never sees you browse |
| Your searches |
Yes, saved to your account history |
Yes |
The text reaches Google anonymously, as you type (autocomplete) and when you search |
| Place pages you open |
Yes |
Yes |
The place lookup reaches Google anonymously, under that logged-out session cookie |
| Turn-by-turn routes |
Yes, full trip telemetry |
Yes |
Routing runs on open OSRM, or OsmAnd-format region files on the phone; Google answers anonymous traffic checks - at planning, and during the drive for re-routes and the optional faster-route scanning |
| Saved places, home, work |
Stored on their servers |
Stored on their servers |
Stored only on your phone |
| Ad profile building |
Feeds your ads profile |
Feeds your ads profile |
Nothing to attach it to |
| Works with no Google contact at all |
No |
No |
Yes - one switch (Settings → Privacy → Use Vela without Google), and downloaded regions show the map, search, route, and navigate fully offline |
Full per-request detail is in PRIVACY.md.
How it works
Every capability, the method behind it, and the file to read first is laid out in
SPEC.md, the authoritative technical specification: the basemap, the places
bake, the Google extractor, open routing, navigation, the offline stack and the signed
remote-repair channel.
| File |
What's in it |
README.md |
This - what Vela is, why, and the privacy comparison |
SPEC.md |
Every technical rule, contract, constant and constraint |
docs/BUILDING.md |
Building from source, module architecture, and the release pipeline |
docs/LANGUAGES.md |
The 15 supported languages, layer by layer (UI, spoken nav, neural voice, dictation), and how to add one |
docs/TRANSLATING.md |
Translating Vela - in the browser on Weblate, or edit one file and open a PR |
FEATURES.md |
The full, categorized list of every shipped capability (the encyclopedia) |
ROADMAP.md |
What is still open + the big bets (self-hosted tiles, OSM contributions, a Play listing, opt-in telemetry, a Vela-own traffic layer); shipped and dead-end entries live in docs/ROADMAP-HISTORY.md |
PRIVACY.md |
Exactly what each Google endpoint receives, per request |
CLAUDE.md |
Build rules, module layout, and the hard-won gotchas - for contributors (human or AI) |
docs/dpad.md |
D-pad / no-touchscreen operation - design, findings, per-surface audit, and the merge-with-upstream policy |
docs/book/ |
Subsystem explainers: how places rank, when data is rebaked, what the camera rules are |
docs/FAQ.md |
The questions people ask first, including what each feature sends to Google |
Degoogled / GrapheneOS notes
- Location: AOSP
LocationManager, never FusedLocationProviderClient. On
GrapheneOS, enabling PSDS (Settings → Location) drops the cold GPS fix from
~30s to a few seconds - Vela shows a one-time tip when it notices a slow fix.
Roadmap
Everything shipped so far is in FEATURES.md (the complete list) and the
release notes of each build. Still open (details in ROADMAP.md):
- F-Droid submission + reproducible build
- A Google Play listing, so Android Auto works on factory head units: a separate build
with the Google half compiled out (map, offline routing, places from OpenStreetMap and
Overture), honestly described, while the full app stays on GitHub, Obtainium and F-Droid.
Play forbids an app that downloads its missing half later, so the two stay two.
A big job (a developer account, review, a flavor split); on the radar, not started.
- An iOS build. The engine module is plain Kotlin and would move to Kotlin Multiplatform;
the map (MapLibre), the neural voice (sherpa-onnx) and the hidden-page scrapes all have
iOS counterparts. The whole interface would be rewritten. On the radar, not started.
Not going to happen - anything that needs you to sign in to Google or hand data to a
backend: contributing reviews/photos/edits, live location sharing and share-ETA, a location
timeline, and the login-gated data Google strips from anonymous requests (live busyness).
Vela's whole point is that no account and no server ever sees you.
A note on the name
Vela Maps (app.vela) - the navigator's constellation "the Sails", and
"sail" in several languages.
Contributing
Read CONTRIBUTING.md first - it covers the hard rules (no
backend, no static Google keys, degoogled runtime, the :core/:app module
boundary, docs-in-the-same-commit, and translations for all 15 languages) and how to
send a change. There is no separate code-of-conduct document by design: keep it
about the code. Security issues go through SECURITY.md (GitHub
private vulnerability reporting), not a public issue.
Map data
The map itself is OpenStreetMap data, © OpenStreetMap
contributors, available under the Open Database License, served as vector tiles by
OpenFreeMap. Offline routing regions, place packs, house-number and
building overlays are built from OpenStreetMap, OpenAddresses and Microsoft Building Footprints
extracts and carry their licenses in the release notes of the hosting release. The places on the
map are Overture Maps (CDLA-Permissive 2.0) and AllThePlaces data, positioned with OpenStreetMap.
Transit boards come from Transitous and the agencies' own GTFS feeds. Satellite imagery is Esri
World Imagery, with Google imagery where Esri has none at close zoom.
License
Vela is Free Software: you can use, study, share, and improve it at your will. You may use, modify, and redistribute this project only if your modifications remain open-source under the same license.
The app bundles the Google Sans Flex font, copyright The Google Sans Flex Authors, under the SIL Open Font License 1.1. Google Sans Flex is a trademark of Google LLC; Vela is not affiliated with or endorsed by Google.
Vela is a degoogled maps and turn-by-turn navigation app for Android that runs with zero Google Play Services. It draws the basemap from open data (OpenStreetMap, Overture Maps, AllThePlaces) and only asks Google's public web endpoints, anonymously and per-device, for things open data lacks like live traffic, reviews and photos.