Know your neighborhood's RF. Keep your family safer.

MyGLE is a community-built Android app that turns your phone into a local RF sensor — WiFi, Bluetooth, cellular, GNSS, and drone RemoteID. Capture observations where you live, work, and travel; understand what's around you; flag the things you didn't invite.

Build it yourself Say hello

What it does

MyGLE is a fork of the excellent WiGLE WiFi Wardriving app with an additional publisher that ships the phone's observations to your own TLS-encrypted MQTT broker. From there, a sibling server-side project decodes and stores the data — the phone is the sensor, the server is the brain.

WiFi

Every nearby access point, its channel, security, signal.

Bluetooth / BLE

Including raw manufacturer payloads for later decoding.

Cellular

LTE / NR / GSM / UMTS / CDMA — towers, bands, neighbors.

GNSS

Per-satellite visibility, for the technically curious.

Drone RemoteID

High-priority notification when a drone broadcasts nearby.

Still uploads to WiGLE

Your collection keeps contributing to the open dataset.

Why a community project?

Personal security isn't just door locks and passwords anymore — the air around your home is full of signals that tell a story. Most of that story is harmless: a neighbor's printer, a car's tire sensor, a visiting cousin's phone. But sometimes it's worth asking what is that, and having your own record to ask it from.

MyGLE exists so families, small communities, and privacy-conscious folks can answer that question with their own data, on their own terms. The app is open and runs on a phone you already own. The server side can be something you host yourself — or, eventually, something we host for you.

Coming later: a managed backend for people who want the insights without running their own server, plus a donation page so folks who can afford to help keep the lights on for everyone else.

What's working today

2026-04-19 this afternoon — api.mygle.net is live.

Public MyGLE REST API is live at api.mygle.net. Ships with Tier 2 anonymous device auth (each device registers a hardware-backed Ed25519 keypair with the server; no email ever required to hold an account), a real cell-tower search endpoint that joins per-user observations against a tower-position dataset (not a stub), and an account-gated auto-ingest toggle for CSV uploads (off by default for anonymous devices; on by default for Tier 1 accounts, user-togglable either way). Path shapes mirror the WiGLE API so existing tooling can point at MyGLE by swapping the base URL.
Dual-mode URL resolution, shipped end-to-end. The app ships defaulting to WiGLE mode for continuity with the existing community workflow. Flip the drawer toggle to MyGLE mode and every network call — news, search, upload, registration, rankings, stats, CSV/KML export — routes to your chosen MyGLE server instead of api.wigle.net. Default MyGLE base URL is api.mygle.net; self-hosters paste their own URL in Settings. Mode flip is live, no restart. Our server is never a chokepoint — user bandwidth, user key, user tiles.
MapLibre ambient tile cache (default behavior), shipped. The map now uses MapLibre in place of the inherited Google Maps SDK. MapLibre keeps its own on-device tile cache by default, so recently-viewed regions stay available offline automatically — no user action required. Tile style URLs and base URLs are user-configurable preferences; Esri World Imagery is the default satellite layer. Full user-facing cache controls (configurable size, TTL, clear-on-exit, storage inspector) are on the near-term roadmap — see below. No tile bandwidth touches MyGLE infrastructure.

2026-04-19 earlier today — architecture round.

Two app modes, user-flippable anytime. MyGLE mode and WiGLE mode. Map sources, uploads, news, and rankings switch by mode; scanning and filter lists behave the same in both. The nav-drawer shows Mode: WiGLE or Mode: MyGLE — tap to flip. Not a one-time choice.
Lists is a first-class menu item. Blacklist / Notify / Whitelist each get a dedicated card with live entry counts at the top-level nav drawer — no more hunting through settings.
Filter-list badges in the network list. Devices on your Blacklist / Whitelist / Notify lists show a visual badge on their row, so you can see the filter is actually applying.
Configurable add-to-list. Long-press a detected network and pick what to match on — exact BSSID, BSSID prefix, SSID only, or any combination. No more adding ten entries for one router.
Crash reports go where you choose. Two paths, both opt-in: user-initiated email via the Android share sheet, and an opt-in MQTT crash_report_message publish that lands on your broker. Pick one, both, or neither. Zero third-party crash SDKs.
Server backend grew beyond ingest. New REST endpoints for the MyGLE-mode experience: bounding-box observations for the map, global BSSID/SSID search, bulk upload for MyGLE-mode uploads, server-authored news, and a per-device dashboard. Full schema contract documented as a cross-project SSoT.
End-to-end roundtrip smoke-tested. During the R5 cycle: +1102 observations captured on a Pixel 3 → published to the broker → ingested by the server → queryable via REST within seconds.
Plugins are the architectural pillar. The phone collects clean observation data; plugins interpret it. Near-term plugins include a cell-tower anomaly / IMSI-catcher correlator, an Evil-Twin WiFi detector, and LLM-assisted natural-language analysis with your own API key (Anthropic, OpenAI, OpenRouter, or a local Ollama — you pick).

2026-04-18 yesterday — public-release prep.

Credentials-clean public build. Stripped all internal broker host / IP pin / username / password defaults from the APK. The public build ships with nothing baked in — users configure their own broker (or use the public demo endpoint) on first MQTT enable.
First-use MQTT disclosure dialog. The first time you turn on MQTT publishing, the app shows a non-cancelable dialog explaining exactly what's captured, what leaves the device, where it goes, and how to turn it back off. You have to tap Enable before any data leaves the phone.
Opt-in by default. mqtt_enabled default = false. publish_ble default = false. Nothing transmits until you explicitly enable a destination.
Self-hosted demo stack. One command — docker compose -f docker-compose.demo.yml up — boots a local Mosquitto broker + ingest + REST API so you can verify the full pipeline on your own machine.

v0.1.0 2026-04-17 — first field build.

The end-to-end pipeline is real and demonstrated: a Pixel 3 XL captures observations on a walk, ships them over MQTT (plaintext to a local broker during testing; TLS path via the server-side nginx proxy is in place), and the server writes them to SQLite. All four streams publish live during motion.

Demonstrated & tested:

All four observation streams — BLE (with raw mfgData retained for server-side decode), WiFi beacons, cellular (LTE / NR / GSM / UMTS / CDMA), and per-satellite GNSS. Network-Survey-format JSON over MQTT.
Three-mode filter lists — Blacklist (drop matched observations before any persist or publish — your own gear stays out of every destination), Notify (collect everything, but ping when a target appears — surveillance assistant), Whitelist (only collect matches — device hunting). Match by MAC, BSSID, SSID, or OUI prefix (AA:BB:CC:*).
Add-to-filter shortcuts — long-press any detected network in the scanning list to send it straight into a filter list, or open the per-list management screen and add manually.
Call Detail Record capture (opt-in) — when enabled, snapshots phone-call state transitions and durations (no phone numbers, no contents — uses READ_PHONE_STATE only).
Re-skinned — action bar, page titles, and every screen read "MyGLE". Distinct launcher label from production WiGLE.
Settings live inside Settings — the app's existing Settings screen has a new "MyGLE Publishing" section. Toggle publishing globally or per topic. Override broker host / port / auth / prefix. Set a device label.
Stable per-device identity (UUID + human-readable label) for fleet-provisioning the same APK across many phones.
UTC timestamps + IANA timezone field on every record so the server can render observation times in the user's local clock.
Side-by-side install with production WiGLE (distinct application ID, zero state collision).
Fully containerized build pipeline — no Android SDK on your host.

Shipped but not yet demonstrated in the field: the following code is in the build, but we haven't yet witnessed them fire during a real-world walk. Treat them as "expected to work, waiting on a real opportunity to confirm."

Drone RemoteID detection — code watches for ASTM F3411 BLE advertisements and would fire a heads-up Android notification when one appears. No drone has been nearby during our testing windows yet, so this is shipped-as-intention, not shipped-as-proven.
"Upload your way" button UX — components exist (WiGLE uploads, MQTT publishing, a local replay queue). A unified single-button experience that asks WiGLE / MQTT / both is the intent; the actual production UX is still being shaped.

Data we're already collecting that feeds future analysis (via plugins):

Cell-tower anomaly / IMSI-catcher / Stingray-style detection inputs. The per-call CDR capture (timing + state transitions) plus the continuous stream of cell-tower observations (LTE / NR / GSM / UMTS / CDMA — band, tower ID, signal, neighbors) together provide the raw data an analytical plugin needs to spot a classic tower-spoof pattern: your serving cell suddenly downgrades to 2G right before a call, or a known location's tower ID changes mid-session. The collection is proven; the correlation plugin that turns those signals into a "you were just around a spoofed tower" alert is a near-term roadmap item, not shipped today.
Evil-Twin WiFi detection inputs. The per-scan WiFi observations plus the device's per-location history of trusted APs is the raw data for a plugin that flags "this SSID is advertising with a new BSSID / new encryption" (classic Evil Twin). Again: data collected today; plugin pending.

The program's architectural position: the phone is a sensor that collects clean observation data; analytical plugins — server-side and/or app-side — are where raw data becomes meaningful insight. Plugins include LLM-assisted analysis with a user-provided API key (Anthropic, OpenAI, OpenRouter, or a local Ollama) so users who don't want a hosted backend can still ask natural-language questions against their own phone's local database. See the roadmap section for the two paths (server-side via MCP, app-side via BYO API key).

Full history in CHANGELOG.md; full backlog in ROADMAP.md. We try to be honest about what's proven vs. what's intention — if you see a claim on this page that doesn't match your experience of the build, tell us.

Privacy-focused features

MyGLE is designed for users who care what leaves their device and what stays on it. A few features serve that directly, both shipped today and on the near-term roadmap:

Opt-in to every destination. Nothing leaves the phone unless you explicitly enable a destination and supply its address. No baked-in servers, no analytics, no crash-reporting SDKs, no Google Play install tracking.
Two account tiers. Tier 1 is the easy path — email + optional password, magic-link recovery. Tier 2 is the email-less path — username + passphrase only, no email trail ever associated with the account. Recovery on Tier 2 is limited to your own registered devices; there's no "reset via email" because there's no email.
Device roles. A phone can be registered as a Limited device — it publishes observations but cannot read server-side data (no search, no maps, no stats). Compromising a Limited device reveals the app and the broker address, nothing more. (Near-term.)
Wire-only storage mode. Opt-in flag that bypasses the on-device database entirely — observations flow to the outbound queue and then to your chosen broker; no local history is kept. Device forensic analysis finds no observation record. (Near-term.)
Configurable push triggers. Push only when on specific WiFi networks you trust (home, a particular café), only on cellular, only when charging, or combinations. Useful if you don't want traffic patterns to indicate where and when you are. (Near-term.)
Hardware-backed device identity. Each device registers via a hardware-backed KeyStore keypair (with StrongBox where supported). Spoofing the identity requires physical possession + root; the key never leaves the phone's secure element. (Near-term.)
Self-host everything. Run your own mygle-server — one docker compose up away — and no observation data touches third-party infrastructure.
Server-side filter-list hosting (v2 roadmap) — your Blacklist / Whitelist / Notify entries live on the server instead of the device, so device forensics can't leak which SSIDs or BSSIDs you're watching.

Example use case: journalist in a restrictive country. Tier 2 account (no email trail) + Limited role (publish-only) + wire-only storage (no local DB) + a push-trigger set to a specific café WiFi. The device carries an app and a broker address; it has no email account associated, no observation history on disk, no filter list stored locally (when v2 server-side lists ship), and uploads only when the user chooses to be on a specific network. Device forensic analysis reveals an app installed, and that's it. None of this is exclusive to journalists — the same feature mix serves anyone who wants minimum-footprint operation (activists, domestic-abuse survivors avoiding tracking, security researchers under NDA, or people who just prefer their phone not to be a ledger of their movements).

Where it's headed

The short answer: make the privacy controls excellent, make the background behavior boring-reliable, and open up a server-side project so people don't have to stand their own up to get value.

Privacy by default — the public release

For the public release, every data destination is opt-in and configured by the user: nothing leaves your phone unless you explicitly enable a destination and supply its address yourself. The easiest paths will be WiGLE.net upload (existing community workflow) and a CSV / database dump straight from the phone — no server required. If you want the live MQTT pipeline, you bring your own broker; if you'd rather use the project's hosted broker once it's available, you'll provision it with a short human-readable passphrase (six random words and a few digits) — no API keys to fumble with, no defaults baked into the APK.

F-Droid listing

For the public release, MyGLE targets a clean F-Droid listing with zero anti-features applied. The inherited Google Maps SDK has already been replaced with the FOSS MapLibre renderer (shipping today); ML Kit dependencies get replaced with manual-entry alternatives, and the build is set up for reproducible builds on F-Droid's build server. The community privacy audit at research/privacy-audit/ in the repo enumerates the remaining work.

Three-tier offline maps + privacy cache controls

Maps are built as an offline ladder, by design, with no operator-hosted tile server. Tier 1 — ambient cache (shipping today: MapLibre's on-device cache of recently-viewed tiles, no user action required). Tier 2 — Download Region (near-term: draw a bounding box on the map, the app prefetches all tiles in that region for offline use). Tier 3 — Mapsforge (near-term: point the app at a full-country .map file you downloaded yourself from mapsforge.org — fully deep-offline, renders vectors on-device, never touches the network).

Alongside the ladder, a set of privacy-first cache controls (near-term): default 100 MB cache with a 7-day TTL, user-configurable all the way down to Off (no persistence). Clear-on-exit, a "clear everything" button, and a storage inspector that shows exactly which tiles are on-device — all give you complete control over the forensic footprint of your map browsing. Esri World Imagery is the default satellite layer (free for non-commercial use with attribution); tile style URLs and base URLs are user-configurable preferences, so self-hosters can point at their own tile server.

Geo-bound filter lists ("bubbles")

Each filter entry can be scoped to a geographic region. Inside this 100-meter bubble around home, blacklist these MACs (privacy). Outside, record everything (situational awareness). A stronger variant pauses scanning entirely inside the bubble — better privacy, longer battery. Bubbles editable on a map view in the filter-list screen.

Search history to seed filter lists

Today, you add filter entries by typing or by long-pressing a currently-detected network. Coming: search the local history of everything you've ever seen, filter by SSID glob / OUI vendor / last-seen window, one-tap add to any list. When server-side communication exists, the same search can hit your circle's shared database.

Rogue infrastructure detection (Evil Twin + IMSI catcher)

The defensive-security flagship. Build a per-user trusted-AP fingerprint (the BSSIDs, encryption types, and locations of WiFi networks your phone normally connects to) and a per-location trusted-tower fingerprint. Alert when an AP advertising your home SSID appears with a new BSSID or weakened encryption (Evil Twin), or when at a known location your serving cell switches to an unfamiliar tower with a forced 5G→2G downgrade (classic Stingray fingerprint). The opt-in CDR capture above is the timing input that makes this sharp.

Resilience — store and forward

A local rich-format queue when your broker is unreachable, with conditional flush (any-network / WiFi-only / 5G / charging-only) so mobile data isn't surprised. Plus a wake-lock + watchdog in the publisher so the manual-relaunch workaround goes away. A periodic device-status heartbeat so a server can tell the difference between "phone went quiet" and "phone went dark."

Per-user reports feed

A pull-based authenticated digest, shaped like RSS but scoped to your own account. The server (or a self-hosted server) runs analytical plugins that generate report items just for you: weekly roundups of what you've seen, interesting AP name patterns, anomaly alerts when something new turns up near your home zone, milestone events ("100k observations"), monthly summary heatmaps. Each kind is individually opt-in; defaults lean privacy-first (e.g. "interesting SSIDs" is off by default). Tier 1 accounts can optionally get the same digest delivered by email. Full cross-repo spec lives at docs/PER-USER-REPORTS.md.

AI insights — two paths

Natural-language analysis of your data, designed for two use cases. Server-side: if you run the MyGLE backend (or use a hosted one), the analytics server exposes an MCP interface — Claude Desktop, Cursor, or any MCP-aware client attaches and you ask questions like "did anyone come near my house overnight?" across your full multi-trip history. App-side BYO key: if you don't want to run a backend, you can plug in your own LLM API key (Anthropic, OpenAI, OpenRouter, or a local Ollama) and the app queries it directly against your phone's local database. Same questions, smaller history. Default in both: nothing leaves your device unless you explicitly enable a destination.

Community groups & neighborhood watch

An opt-in concept for circles of households or neighbors who choose to share their MyGLE observations into a common pool. Each contributor controls what they share into the circle (per-circle blacklist, per-circle data-class toggles, per-circle retention) — your private observations stay private; only what you allow joins the shared picture. Use cases: a neighborhood-watch circle that gets sharper anomaly detection from collective baselines than any single household could alone; a family circle where parents and kids can find each other's devices across multiple sensors; opt-in regional circles that propagate "watch for this MAC" alerts when someone's missing a phone, a device, or a person.

Ecosystem — the server project

A separate open-source repo (MyGLE Server, coming) that stands up a personal MQTT broker, ingest pipeline, and analytics. Same friendly onboarding as the phone side — if you can run Docker, you can run your own MyGLE back-end. Later, behavioral persona detection so the server learns the difference between your own devices, your car's devices, and unfamiliar companions.

Managed service — when the community's ready

For folks who want the insights without operating a server: a managed MyGLE backend you can point the app at, supported by donations. Still open-source client and server; the donation page just keeps the lights on.

Full backlog + architectural principles live in ROADMAP.md. If you'd like to suggest a priority, drop a note.

Build it yourself

The whole build runs inside a container — no Android SDK install required on your machine. If you can run Docker, you can build MyGLE.

git clone <repo-url> mygle
cd mygle/docker
./build-apk.sh

First build pulls Gradle, the Android SDK, and all dependencies into a named volume. Subsequent builds reuse the cache. The APK lands at:

wigle-app/wiglewifiwardriving/build/outputs/apk/debug/wiglewifiwardriving-debug.apk

Install via ADB:

adb install -r wigle-app/wiglewifiwardriving/build/outputs/apk/debug/wiglewifiwardriving-debug.apk

MyGLE installs under a distinct application ID (with a .mygle suffix on debug builds), so it runs side-by-side with production WiGLE without conflict. The launcher label shows as MyGLE so you can tell them apart.

Configure

Defaults are baked in — broker, TLS, all four publishers on. Override from inside the app (action bar overflow → mygle settings) for broker host/port/auth/topic-prefix, or set a human-readable Device label if you're fleet-provisioning multiple phones with the same APK.

A repo link will appear here as soon as the project's code is public. For now, if you'd like early access, email hello@mygle.net.

A big thank-you to WiGLE

MyGLE is built on top of the WiGLE WiFi Wardriving Android app, which has been actively maintained for over a decade by the WiGLE.net team (Andrew Carra, Robert Hagemann, Hugh Kennedy, and contributors). Years of careful work on background scanning, BLE capture, and speed-adaptive collection made this project possible.

MyGLE is a BSD 3-Clause derivative, released under the same license, with additions scoped to a single package (net.wigle.wigleandroid.mygle) so the upstream project stays cleanly separable. The original copyright notice and license are preserved in every build.

Not endorsed by WiGLE.net. The name "WiGLE.net" and "Mimezine" are trademarks of their respective owners; MyGLE uses neither name to promote or endorse the fork.

Say hello

Questions, ideas, RemoteID oddities you've spotted, or just interest in following along? Drop a note:

Email: hello@mygle.net
Mirror domain: mygle.org → redirects here.

Mail is hosted on a self-run Stalwart server — no third-party mailboxes, no training on your words, no surprise filters.