# Grid-Mobile shares live location over Matrix, with no tracking account

> Grid-Mobile is a Flutter app for iOS and Android that encrypts your position on the device and carries it over Matrix, so the server that relays it never holds readable coordinates. The trade-off is a homeserver, a map provider and a licence that needs reading before you ship it.

**Rezivure/Grid-Mobile** — Grid: Private Location Sharing mobile app for iOS/Android. E2EE with Matrix.

- Repository: https://github.com/Rezivure/Grid-Mobile
- Website: https://mygrid.app
- Stars: 571 · Forks: 47
- Language: Dart
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/rezivure-grid-mobile

## Grid shares your position over Matrix instead of a tracking account

Grid is a Flutter mobile app for iOS and Android that shares your location with a person or a group you choose. The problem it addresses is narrow and ordinary: most location sharing hands a live position trail to somebody else's server, and the person receiving it has no way to see what is retained or to stop it. Grid's answer is to put location on top of Matrix, the federated protocol that already carries encrypted messages, and to encrypt the position on the phone before it goes out. The repository description calls it "E2EE with Matrix", and the feature table states that location data is encrypted on your device and that the server stores ciphertext it cannot read. The app store screen copy also promises "no phone or email required", so you are not handing over a carrier number or an email address just to be visible on a map. The audience is therefore people who already dislike that trade: family groups, small crews meeting up, and anyone who wants a short-lived live position rather than a permanent history.

## The homeserver relays ciphertext it cannot read

Matrix is the transport and storage layer, and the feature table describes it as decentralized rather than as a single vendor's database. That matters for the privacy claim, because the party that knows your contacts is also the party that could abuse them. In Grid's arrangement, that party receives encrypted blobs. It can route them between the people in the group, but reading the coordinates would require the keys that never left the phones. The other part of the design is revocation. The table lists real-time sharing with an individual or a group, the ability to revoke it at any time, and fine-grained control over who sees you and for how long, with sharing toggled off on demand. The practical consequence is that a live position is a lease rather than a record. Whether a server keeps the ciphertext of a revoked share is a separate question, and neither the README nor the docs excerpt provided here answers it, so treat revocation as a UI control over future transmissions rather than as proof of deletion on the far side.

## Cloning Grid-Mobile and pulling the Flutter dependencies

End users do not need any of this, since the README links both an App Store listing and a Google Play listing. Contributors do. The getting started section lists Flutter, Android Studio, Xcode and CocoaPods as prerequisites, with Xcode and CocoaPods only needed for iOS work, and the installation steps are a clone, a dependency fetch and an environment file copy:

```bash
git clone https://github.com/Rezivure/Grid-Mobile.git
cd Grid-Mobile
flutter pub get
cp .env.example .env      # then edit .env with your API and server URLs
```

Android needs nothing beyond that. iOS needs its native dependencies pulled in first:

```bash
cd ios
pod install
cd ..
```

The run step is the standard Flutter launcher:

```bash
   flutter run
```

The surrounding notes are practical rather than promotional: open the cloned folder in Android Studio, confirm the Flutter SDK is configured, start an emulator or attach a physical device, and check that the device is detected before building. The repository layout supports that workflow, with lib/ holding the application code, assets/ holding images and icons, and pubspec.yaml declaring dependencies and assets. No build flags, version pins or platform toggles are documented, so there is nothing here to adjust beyond the environment file and the standard Flutter toolchain.

## The .env file decides which homeserver and map provider the app talks to

The single most important configuration step in the repository is copying .env.example to .env, and the comment in the installation snippet makes that explicit. The example file is short and reads like a deployment manifest. It defines MATRIX_SERVER_URL, HOMESERVER and GAUTH_URL for the Matrix side of the system, MAPS_URL and SAT_MAPS_URL for tile sources, and PROFILE_PIC_CDN_URL for avatars. It also carries APP_STORE_URL, PLAY_STORE_URL, VERSION_CHECK_URL and SUBSCRIBE_URL, which are service endpoints rather than secrets, plus TURNSTILE_SITE_KEY, the one entry that names a bot-protection service. No default value is filled in for any of these, so a developer who copies the file and runs the app without editing it has no server to talk to. Two consequences follow for evaluators. First, switching a deployment between the hosted service and your own backend is an environment change, not a rebuild. Second, the presence of GAUTH_URL alongside HOMESERVER shows that identity and transport are configured separately, which is the usual shape for a Matrix deployment, but the exact role of each value is not spelled out in the file itself.

## Self-hosting Grid means leaving this repository behind

This is the point where the project's scope and the project's ecosystem come apart, and it is easy to misread the badge that says self-hostable. The README states plainly that this repository is for the Grid mobile application for iOS and Android, and that anyone wanting to self-host a server should consult the documentation site at docs.mygrid.app or the community Discord. The feature table adds that a self-hosted setup means running your own backend server and your own map tile provider, which is two services beyond the phone app. So the open source code in Rezivure/Grid-Mobile covers the client, the client configuration surface and the test infrastructure, including .maestro/, run-maestro.sh, test/, test-infra/ and fastlane/ directories plus a scripts/ folder, while the server side lives elsewhere. The cost picture for a team that wants full control is therefore larger than a single repository clone, and anyone budgeting self-hosting needs the server project's own documentation, licence and upgrade story before assuming the two move in step.

## Where Grid is the wrong tool

Several cases fit badly. If you cannot or will not operate a Matrix homeserver and a map tile provider, Grid has nothing to talk to, and the hosted My Grid service is the only path the material describes. If your requirement is an audit trail that survives a phone being lost, revocation semantics work against you, since the design intent is to stop sharing rather than to preserve it. If you need a public REST API, a web build, a desktop build or a command line client, the README documents none of those, and the topic list and directory layout show a mobile-only Flutter project. If you need to send your position to a service that cannot join a Matrix room, a relay or webhook integration, there is no mention of one. There is also no documented fallback if a homeserver goes down, and the README does not document rollback, upgrade notes for the client, or a migration path for a group that moves between deployments.

## A Matrix room instead of a hosted location dashboard

The approach differs from the ordinary location sharing service in one structural way rather than in a long list of features. A conventional service keeps a central account system with plaintext coordinates, produces a share link or a map view, and gates access through that account. Grid removes both the account and the readable coordinate from the server's hands: identity comes from the Matrix ecosystem, transport is federated between homeservers, and the payload stays encrypted until a member of the group opens it. That buys two things. A hosted operator can forward traffic between participants without becoming the party that knows where everyone is, and a group can move its whole arrangement to a homeserver it controls without changing the app, because the environment file is where the endpoint lives. It also gives up things a dashboard gives you: no server-side query, no historical trail, no third-party integrations, and no way for an administrator to see that a participant is offline. A team that needs a dispatcher's overview of a fleet has the wrong tool here, while a group of a dozen people who want a live dot on each other's map fits the design well.

## A custom licence file, mobile builds, and a last push on 2026-10-04

The repository is not archived and the last push was on 2026-10-04, so the code is being worked on, with the most recent releases being v2.1.0+1002 on 2026-09-14 and v2.1.0+849 on 2026-09-13, and v2.0.1+840 before that. The version strings carry a build counter after a plus sign, the pattern used for store uploads, so a consumer of the app receives updates through the App Store and Google Play rather than through the source tree. That keeps the upgrade path for end users ordinary, while contributors face the standard cost of a Flutter client: pull main, refresh dependencies, and rebuild. On licensing, the README states the project is licensed under the GNU Affero General Public License v3.0 and links the LICENSE file, yet the licence category GitHub shows is a custom one that the service cannot classify, which is a real discrepancy to resolve before adoption. Read the LICENSE file and confirm which terms actually govern the code you copy, especially if you intend to modify the client and run your own server, and treat this as a legal question for your own counsel rather than as a settled reading of a badge.

## Conclusion

Adopt Grid-Mobile if your group already runs Matrix or accepts running a homeserver and a map tile provider, and if end-to-end encrypted location fits your threat model. Do not adopt it if you need a server-free setup, a documented public API, or a licence whose terms your legal team has already cleared. Before you commit, read the LICENSE file yourself, because the licence category GitHub shows for the project is a custom one that it cannot categorise while the README calls it AGPL v3.0, and confirm on the My Grid docs exactly which pieces you must operate.

## FAQ

### What licence is Grid-Mobile released under?

The README states that the project is licensed under the GNU Affero General Public License v3.0 and points to the LICENSE file for details. The licence category GitHub shows for the project is a custom one that the service cannot categorise, so read the LICENSE file yourself before you depend on it.

### Do I need a phone number or email address to use Grid?

The app screen copy states that no phone or email is required, and the .env.example file lists MATRIX_SERVER_URL, HOMESERVER and GAUTH_URL as the endpoints a deployment provides. The client runs on Matrix, so a homeserver is part of any deployment regardless of how you host it.

### How do I self-host a Grid server?

This repository contains the iOS and Android mobile application only. The README points to the documentation at docs.mygrid.app, or the project Discord, for self-hosting a server, and the feature table notes that a self-hosted setup means running your own backend server and map tile provider as well.

### How do I build Grid-Mobile locally to contribute?

Clone the repository, run flutter pub get, and copy .env.example to .env with your API and server URLs. iOS work additionally needs pod install inside the ios directory, and the app is then launched with flutter run against an emulator or a physical device.

## Sources

- [Issues](https://github.com/Rezivure/Grid-Mobile/issues)
- [Project website](https://mygrid.app)
- [README](https://github.com/Rezivure/Grid-Mobile/blob/main/README.md)
- [Releases](https://github.com/Rezivure/Grid-Mobile/releases)
- [Rezivure/Grid-Mobile on GitHub](https://github.com/Rezivure/Grid-Mobile)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rezivure-grid-mobile