Open GPX Tracker and a no subscription limit GPS logger for iOS

A logger with no time limit and no ads

Open GPX Tracker is a GPS logger for iOS on iPhone, iPad and iPod, with offline map cache support, and it is written in Swift. The stated uses are creating routes and waypoints for editing OpenStreetMap, publishing OpenStreetMap Traces, creating GPX files for testing iOS apps in Xcode, and using it as a GPS companion when taking pictures with a reflex camera.

The feature list in the readme is dominated by one deliberate omission. The app has no annoying time restrictions, no ads and no in-app-purchases, and you can create unlimited GPX traces. That is a real differentiator in this category, where the common pattern is a free tier that records for an hour or two and then asks you to pay.

Everything else follows from being a GPX logger rather than a fitness app. The app displays the tracking route on a map, and it supports Apple MapKit, OpenStreetMap and Carto DB as map sources. There is pause and resume, waypoints can be added at the current location or at any place on the map with a long press, and a waypoint can be renamed or dragged to a new position or removed. A saved session can be loaded onto the map and tracking continued from it.

The live readouts are the ones a tracker needs: current location and altitude, tracked time, user heading from device orientation, location accuracy, and tracked distance both in total and for the current segment. Dark mode is supported, and the multi-language support list is unusually long, with German, English, Spanish, Finnish, French, Italian, Japanese, Dutch, Portuguese (Brazil), Russian, Ukrainian and Simplified Chinese, credited to volunteers.

Offline maps come from browsing ahead of time

The offline map support is the feature with the most specific usage rule, and it is worth reading the README wording closely.

If you are going to track without internet, the documentation says not to worry, but the advice is to browse the area where you will be tracking before you go offline, and then it will be cached and available offline. That is a different model from an app that downloads a map region on demand for a chosen area and radius.

The cache is also a setting, in the sense that the settings screen offers an offline cache on or off control and a clear cache action, alongside a map server selection. So the behaviour is: as you browse, tiles are cached, and the cache is what you have when the network is gone.

That design has an obvious consequence. The area you can use offline is the area you happened to browse, not the area you plan to visit. If you are going somewhere new, you need to browse it first, while you still have a connection, which for a remote trail means doing it at the trailhead with whatever signal you have.

The map source list is also the point where the project's obligations become visible. The README carries a note about the limitations of using OpenStreetMap tile servers and points at the OpenStreetMap wiki tile usage policy, and it separately lists a list of tile servers in that same wiki. The official tile servers are run as a shared service with a usage policy, and the project is careful to point you at it rather than to assume unlimited caching.

Adding your own tile server is the documented escape route. The README says adding a tile server is easy, that you edit the file `GPXTileServer.swift`, uncomment the lines with `AnotherMap` and modify the templateUrl to point to the new tile server. That is a source edit rather than a settings screen control, which tells you the intended audience for a custom server is someone willing to rebuild the app.

The Apple Watch app records independently and hands the file over

The Watch features are listed as a separate block, described as available since 1.6.0, and they are more than a remote control for the phone.

On the watch you can create GPX files, pause and resume tracking, save into a GPX file, add a waypoint to your location, and send the file to your paired iPhone or iPad. The watch also displays GPS signal strength, and it shows current location information including speed, latitude, longitude and altitude.

That is a distinct feature set rather than a mirror of the phone. The watch creates the file itself rather than mirroring a phone session, and the file transfer to the paired device is a separate step. The GPS signal strength readout is the detail that matters most in practice, because on a watch under tree cover or on a body, a poor signal is the difference between a clean trace and a track full of drift.

The repository layout shows two separate targets for this: `OpenGpxTracker-Watch/` and `OpenGpxTracker-Watch Extension/`, alongside the main `OpenGpxTracker/` directory, the test directory `OpenGpxTrackerTests/` and the Xcode project `OpenGpxTracker.xcodeproj/`. The watch app being a separate target with its own extension is the standard shape for a watchOS app that shares code with an iOS app, and it means the watch build has its own lifecycle rather than being a mode of the phone app.

The top level also carries `.jazzy.yaml` for the documentation generator and `.swiftlint.yml` for the linter, both of which come back in the contribution rules.

GPX files move in and out through the share sheet

The interop story is the share sheet, and it is what makes the app useful in a workflow rather than a standalone recorder.

GPX files can be imported from any other app using the share option, and GPX files can be shared with other apps. There is also file sharing through iTunes, and the app can send your logs by email as GPX files. In other words, the track is not trapped in the app's own storage; it is a document that other apps can read and produce.

That direction of travel matters as much as the export. The listed use case of creating GPX files for testing iOS apps in Xcode links to a walkthrough on simulating locations in Xcode, so the app doubles as a source of realistic movement data for development. For an OpenStreetMap contributor, the same file format is the submission format, and the app is explicitly framed around creating routes and waypoints for editing OpenStreetMap and publishing traces.

The privacy position is stated in the same terms. The readme says all the data recorded using the application is kept on your phone, or in your iCloud, wherever you store it, and that the app does not share any GPS data with the maintainers or any other third party, with a link to a privacy policy page in the wiki. The iCloud option is worth noting because it means the data location is a user choice rather than a fixed behaviour, and the phrase wherever you store it is doing that work.

There is a small oddity in the source, an apparent typo in the readme describing the third party wording, which is the kind of thing that suggests the text has not been reread in a while. It does not affect the behaviour, but it is a fair signal about how carefully this particular document is maintained.

Building it yourself, and the tile server edit

Installation has two routes. The app is available on the App Store, and has been since May 2015. The alternative is to download the source code and compile it yourself using Xcode and the iOS simulator, and if you want to run it on a physical device you also need an Apple developer account.

The development workflow is deliberately short. To download the code you run:

 git clone https://github.com/merlos/iOS-Open-GPX-Tracker.git

and then open `OpenGpxTracker.xcodeproj` with Xcode to test it. The one leading space in that command is how it appears in the project's own documentation, and it works either way.

The custom tile server route is the same kind of thing. You edit `GPXTileServer.swift`, uncomment the lines with `AnotherMap` and modify the templateUrl to point at your own server. There is no configuration file for it, which means changing the tile server means changing code and rebuilding.

Reference documentation is generated with jazzy, following the NSHipster tutorial on Swift documentation, and the generated site lives at the project domain with a documentation status badge in the readme. The project also ships a `.ruby-version` file, which is the trace of the jazzy toolchain being Ruby based.

So the build story is a conventional Xcode project: clone, open, build, run in the simulator. There is no package manager, no dependency resolution step, and no CocoaPods or Carthage step mentioned. For a Swift application of this age and shape that is not unusual, and it does mean the project is straightforward to fork and modify.

The GPL and the App Store binary, and the rules for a pull request

The licensing situation is the part that needs a decision from you rather than a summary.

The source code is licensed under GPL 3.0, and the copyright line reads Open GPX Tracker app for iOS, Copyright (C) 2014-2023 Juan M. Merlos and Contributors, with the standard redistribution and modification notice that follows. The project also carries a `LICENSE.txt` at the root.

The pull request licence note is the part most contributors miss. It says that though the source code is licensed under GPL 3.0, by submitting a pull request you are also providing the rights to distribute those changes in the binary app published on the App Store, which is released under Apple's Standard License Agreement.

That is a dual arrangement between the source licence and the distribution licence of the shipped binary, and it is a deliberate choice by the maintainer to keep one App Store binary while the source stays copyleft. It also means a contributor is agreeing to two sets of terms at once, which is why the note is called out so prominently.

The contribution conditions are strict in a useful way. Text displayed in the application must be internationalised with `NSLocalizedString`, and the keys have to be added to all the `lproj` files kept organised in the same way, roughly the same line, and the readme suggests using ChatGPT or DeepL for the translation work, with a sample prompt included. You need to install swiftlint and not introduce additional lint warnings. And you must document the classes and methods you create, explaining what they do from a blackbox perspective, using jazzy, which is installed with:

    gem install jazzy

and run with:

    jazzy

which generates the documents in the `../gh-pages/docs` directory. In other words, a pull request is expected to arrive with translations, lint clean and documentation, not just working code.

Where this app is the wrong choice

There are three situations where Open GPX Tracker does not fit, and none of them are about the tracking itself.

The first is a managed fleet of devices. This is a single user iOS application with an iCloud sync option, not a device management story. There is no configuration, no policy, and no way to push settings to a team. For an organisation that issues phones to field staff, that is a gap that the App Store distribution model does not fill.

The second is a commercial product that needs to embed the code. The source is GPL 3.0, and a derived application distributed to users carries the copyleft obligations with it. The project itself demonstrates the alternative arrangement, where the App Store binary is under Apple's licence and the source stays open, but that arrangement is a decision the maintainer made and it does not extend to your product.

The third is heavy offline map use. The offline story here is a cache of what you browsed, built on shared OpenStreetMap tile servers whose usage policy applies. A team that needs guaranteed offline coverage of a defined region for a set of users should be running its own tile server, and configuring that means editing `GPXTileServer.swift` and rebuilding, as described above.

On the positive side, the app is unusually honest about what it does not do. There is no social layer, no route planner, no fitness training programme, no premium tier. It records tracks, it caches maps, it manages waypoints, and it produces GPX files. For the person who wants exactly that and wants to own the file, the absence of everything else is the feature.

Editorial conclusion

Open GPX Tracker fits a hiker, cyclist or OpenStreetMap contributor who wants an unlimited track logger with offline map caching and a GPX file they control, and who is willing to read the OpenStreetMap tile usage policy before caching an area. It is the wrong choice for a team that needs a managed fleet of devices, a commercial support agreement, or a licence that permits redistribution inside a closed product. Before installing, check two things: whether the tile servers you intend to use permit the offline caching the app does, and whether the GPL-3.0 terms on the source work for you, because the project states that contributors also grant the rights to distribute their changes in the App Store binary. The app has been on the App Store since May 2015, the newest release is v1.10.1 from 2025-12-20, and the last push was on 2026-08-25.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. merlos/iOS-Open-GPX-Tracker on GitHub
3. Project website
4. README
5. Releases