Google Timeline Visualizer gained 575 GitHub stars in a day by solving the awkward last mile of Google Maps' location-history overhaul. Google now keeps Timeline history on a device and offers a JSON export, but a portable file is not the same thing as a usable record. This open-source project turns that export into an animated travel video locally, without asking for a Google login or uploading the route file.
That distinction explains why a small utility can suddenly attract attention. Google has made Timeline more private at the storage layer, while also removing it from desktop Maps. Users who want to do more than browse old journeys inside the mobile app must find the export, understand its changing formats, and supply their own software. Google Timeline Visualizer packages those steps into an Android app, an iPhone web app, and a Python program for desktop users.
A usable layer on top of Google's export
Google's current Timeline documentation says visits and routes are saved on each signed-in device. An optional encrypted backup can be stored on Google's servers and imported to another device, but Timeline itself is no longer available in Maps on a computer. On iPhone and iPad, Google documents an export path inside Maps that saves a location-history JSON file through the iOS share sheet.
The Android path is less obvious. The visualizer's instructions send users to the phone's Settings app, then Location, Location services, and Timeline, rather than to the Maps interface. Menu names can vary between phone makers. Once exported, the file is selected explicitly in the visualizer; the app does not obtain it through account access or a location permission.
The project accepts current Android and iOS direct-array exports as well as older files containing semanticSegments. It handles visits, activities and paths, several coordinate representations, and routes that cross the international date line. That compatibility work is the unglamorous center of the project. A visualizer that supported only one generation of Google's schema would be of little use to people whose history spans years or has moved between devices.
After loading a file, a user can choose exact dates or a month range, set a title, select camera behavior and choose a journey length from 10 to 300 seconds. Older travel fades as the marker advances. Sparse long-distance legs are interpolated along a great-circle path, while an optional conservative filter ignores isolated, implausible out-and-back GPS points without modifying the original JSON.
The result is an MP4 rather than another proprietary database. On Android 10 and later, it is saved under Movies/Timeline Visualizer; older Android versions use the system Save As picker. The app also keeps a local index of generated videos with thumbnails and dates, while leaving the actual MP4 files in device media storage.
Version 2.2.0 widens the output
The surge arrived alongside version 2.2.0, released on August 20. The update adds fixed portrait 1080 by 1920 and landscape 1920 by 1080 formats to the existing square outputs. Preview screens and final journey overviews now follow the selected aspect ratio, including their titles, dates, markers and attribution.
This is a practical release rather than a rewrite. Portrait output fits phone viewing and short-form sharing, while landscape video works better on conventional displays. The app checks whether the device's H.264 encoder supports the requested dimensions, frame rate, bit rate, alignment and color layout before it prepares map tiles. Unsupported combinations are disabled with an explanation instead of being silently replaced. Existing square settings and pending exports are preserved.
The release also exposes all choices when a settings menu is reopened and reports the installed version and build code. The project supports nine interface languages: English, Korean, Japanese, Simplified Chinese, Traditional Chinese, Spanish, French, German and Brazilian Portuguese. Format-preset work came from an outside contributor and was integrated by the maintainer, a modest but concrete sign that the repository is functioning as a community project rather than only a code dump.
Android users currently install an APK from GitHub rather than Google Play. That means allowing the browser or file manager to install an unknown app, then optionally turning that permission off. The app requires Android 8.0 or newer. People deciding whether that trade is acceptable can inspect the MIT-licensed source and build it, but source availability is not the same as an independent security audit. Our review of Google Timeline Visualizer covers the setup reality for users weighing that installation path.
Local processing has a precise privacy boundary
Location history is among the most sensitive files a person can possess. It can expose a home, workplace, medical visits, relationships and routines. The relevant question is therefore not whether the project calls itself local, but which bytes leave the device and why.
The project's privacy document says the selected Timeline JSON is never uploaded or copied into app storage. The Android app does not request a Google account, current device location, contacts, photos, advertising identifiers or broad storage access. During rendering, selected route points and export settings are held temporarily in private app storage so work can continue off-screen or survive process recreation; that temporary material is deleted after completion, cancellation or failure and excluded from Android backup and device transfer.
There is still a network boundary. The moving route needs a basemap, and the app requests raster tiles from CARTO using OpenStreetMap data. Standard tile requests include an IP address, user agent and zoom/x/y identifiers. Those identifiers correspond to geographic areas, so CARTO can learn which map regions are being requested even though it does not receive the complete Timeline file, route-coordinate list, video frames or title. The app presents this caveat before loading the first Timeline and lets the user cancel.
That is a more useful privacy description than a blanket claim that everything is offline. Route parsing and video rendering stay on the device, but map imagery comes from the network. Anyone with a stronger threat model would need to inspect the code, consider whether tile access patterns are revealing enough to matter, and potentially adapt the project to use a local tile source. The repository does not claim that the existing configuration hides map access from the tile provider.
The app has no analytics, advertising, crash reporting, login or developer-operated server, according to its documentation. Cached map tiles may remain in the app cache until the user clears it or uninstalls the app. Removing an item from the in-app video list does not delete the MP4; deleting the actual file is a separate confirmed action. These details matter because privacy controls are only useful when users know which action affects an index, a cache, or the underlying media.
The desktop route remains useful
The Android app and iPhone web interface are the most approachable options, but the original Python generator remains available. It requires Python 3.9 or later, FFmpeg and the dependencies listed by the repository. A local run looks like this:
python -m pip install -r requirements.txt
python visualizer.py --input Timeline.json --year 2025 \
--camera-movement steady --long-trip-compression balanced \
--output my-trip-2025.mp4
The desktop path is valuable for more than convenience. It is easier to pin dependencies, inspect the input and output, automate repeat exports, or modify the rendering pipeline on a computer. It also makes the project's underlying promise testable: a user can clone the repository, review the processing code and produce a video without sending the location file to a hosted conversion service.
For developers, the repository is a compact case study in building around user-controlled exports rather than account APIs. Google Sign-In would not grant access to the phone's Timeline history, so adding authentication would increase account access without removing the manual export step. The visualizer instead accepts a document chosen through the operating system and works from that artifact. This is less frictionless than an OAuth import, but the permission boundary is much easier to understand.
Portability needs tools, not just download buttons
Google's on-device Timeline design reduces central access to a detailed location record, and encrypted backup offers a recovery route when enabled. It also changes the surrounding software ecosystem. The web view is gone, server-side integrations cannot assume the history is available through an account, and users must retrieve an export from the device that holds the data.
Timeline Visualizer does not reverse that architecture. It demonstrates what can be built after the platform hands a person a file. Its rapid star gain is best read as interest, not proof of reliability or adoption. GitHub stars do not establish that exports parse correctly on every phone, that long renders complete on every encoder, or that the privacy implementation is free of bugs. The project itself provides unit, lint and build commands, but independent testing remains important for software handling years of precise movement data.
What to watch next is whether the project reaches an official app store, receives broader security review and keeps pace with Google's export schemas. The immediate release is useful and its local-first boundary is unusually clear, but durable data portability depends on maintenance: when the platform changes the file, the independent tool must still be able to read it.