Dawarich is a powerful, self-hosted alternative to Google Timeline that puts you back in control of your location data. This open-source application lets you track, visualize, and analyze your entire movement history with complete privacy, unlimited data retention, and advanced features like photo integration and family sharing. Unlike Google’s increasingly restricted Timeline service, Dawarich gives you permanent ownership of your location memories while offering more visualization options and better integration with self-hosted photo management tools like Immich and Photoprism.
Why it matters: After Google began limiting Timeline to device-only storage and enforcing an 18-month data retention limit, privacy-conscious users needed an alternative. Dawarich solves this by providing a feature-rich, self-hostable platform that never deletes your data, respects your privacy, and works seamlessly with other open-source tools in your digital ecosystem.
The backstory: Created by developer Evgenii Burmakin (Freika), Dawarich emerged from the self-hosting community’s need for a robust location tracking solution. The name comes from German “da war ich” meaning “I was there.” With over 7,100 GitHub stars and an actively growing community of 700+ Discord members, Dawarich has rapidly become the leading open-source alternative to commercial location tracking services. The project is under active development with multiple releases each month, though users should note it’s not yet considered production-ready and requires careful update management.
What Dawarich does and why you need it
Dawarich transforms raw GPS coordinates into meaningful location memories. The platform automatically records your movements through compatible mobile apps like OwnTracks, Overland, or the official Dawarich iOS app, then visualizes this data on interactive maps with multiple customizable layers including heatmaps, route lines, fog of war exploration overlays, and scratch maps showing countries visited.
The application excels at several core tasks. First, it provides comprehensive location tracking with real-time updates from your phone to your server. Second, it offers advanced visualization capabilities including nine different map styles and eight toggleable layers that let you view your data as individual points, connected routes, frequency heatmaps, or explored territories. Third, it enables trip creation and analysis where you can define specific date ranges as trips, automatically generating routes, calculating distances, displaying photos taken during that period, and adding custom notes to document your travels.
Perhaps most importantly for privacy-conscious users, Dawarich gives you complete data sovereignty. Your location history lives on infrastructure you control, with no third-party data sharing, no advertising, no monetization of your movements, and no arbitrary retention limits. You can import your entire Google Timeline history and continue tracking indefinitely, building a permanent, searchable record of your life’s journeys.
The platform also integrates seamlessly with photo management systems. By connecting to Immich or Photoprism installations, Dawarich automatically extracts GPS coordinates from your photos’ EXIF data and displays them as markers on your map. This creates a visual timeline where your location history and photo collection merge, helping you remember exactly where each image was captured and organizing your entire photo library geographically.
Setting up Dawarich: installation and requirements
Currently, Dawarich only supports Docker installation – there is no native or manual setup method available. This containerized approach simplifies deployment but requires familiarity with Docker and Docker Compose.
System requirements are modest but specific. You’ll need a server or computer with at least 2GB of RAM (1GB causes out-of-memory errors), support for either AMD64 or ARM64 architecture, Docker version 20.10 or above, and Docker Compose version 1.29 or higher. The stack runs on any operating system supporting Docker, including Linux distributions, macOS, Windows, and even Synology NAS devices with special configuration.
The database requirements are critical to understand. Dawarich uses PostgreSQL 17 with PostGIS 3.5 extensions for spatial data storage. As of version 0.26.0, the project moved from PostgreSQL 14 to version 17, and these versions are not backwards compatible. The default database image is postgis/postgis:17-3.5-alpine. Additionally, the stack requires Redis 7.4 for caching and background job queuing.
Docker installation process
First, ensure Docker and Docker Compose are installed on your system. On Ubuntu or Debian-based Linux:
# Install Docker prerequisites
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
# Add Docker's official GPG key and repository
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# Install Docker Engine and Compose
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-pluginCreate a project directory and compose file:
mkdir dawarich
cd dawarichCreate a docker-compose.yml file with this configuration:
version: '3.9'
networks:
dawarich:
external: false
services:
dawarich_db:
image: postgis/postgis:17-3.5-alpine
container_name: dawarich_db
shm_size: 1G
volumes:
- ./db_data:/var/lib/postgresql/data
- ./db_shared:/var/shared
networks:
- dawarich
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: password
POSTGRES_DB: dawarich_development
restart: always
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres -d dawarich_development"]
interval: 10s
retries: 5
start_period: 30s
timeout: 10s
dawarich_redis:
image: redis:7.4-alpine
command: redis-server
container_name: dawarich_redis
networks:
- dawarich
volumes:
- ./redis_data:/data
restart: always
healthcheck:
test: ["CMD-SHELL", "redis-cli ping || exit 1"]
interval: 10s
retries: 5
dawarich_app:
image: freikin/dawarich:latest
container_name: dawarich_app
volumes:
- ./public:/var/app/public
- ./watched:/var/app/tmp/imports/watched
- ./storage:/var/app/storage
networks:
- dawarich
ports:
- "3000:3000"
stdin_open: true
tty: true
entrypoint: web-entrypoint.sh
command: ['bin/rails', 'server', '-p', '3000', '-b', '::']
restart: on-failure
environment:
RAILS_ENV: development
REDIS_URL: redis://dawarich_redis:6379/0
DATABASE_HOST: dawarich_db
DATABASE_PORT: 5432
DATABASE_USERNAME: postgres
DATABASE_PASSWORD: password
DATABASE_NAME: dawarich_development
MIN_MINUTES_SPENT_IN_CITY: 60
APPLICATION_HOSTS: localhost,127.0.0.1
APPLICATION_PROTOCOL: http
TIME_ZONE: Europe/London
STORE_GEODATA: "true"
depends_on:
dawarich_db:
condition: service_healthy
healthcheck:
test: ["CMD-SHELL", "wget -qO - http://127.0.0.1:3000/api/v1/health | grep -q '\\\"status\\\"\\\\s*:\\\\s*\\\"ok\\\"'"]
interval: 10s
retries: 30
start_period: 30s
timeout: 10s
dawarich_sidekiq:
image: freikin/dawarich:latest
container_name: dawarich_sidekiq
volumes:
- ./public:/var/app/public
- ./watched:/var/app/tmp/imports/watched
- ./storage:/var/app/storage
networks:
- dawarich
stdin_open: true
tty: true
entrypoint: worker-entrypoint.sh
command: ['sidekiq']
restart: on-failure
environment:
RAILS_ENV: development
REDIS_URL: redis://dawarich_redis:6379/0
DATABASE_HOST: dawarich_db
DATABASE_PORT: 5432
DATABASE_USERNAME: postgres
DATABASE_PASSWORD: password
DATABASE_NAME: dawarich_development
APPLICATION_HOSTS: localhost,127.0.0.1
TIME_ZONE: Europe/London
BACKGROUND_PROCESSING_CONCURRENCY: 5
depends_on:
dawarich_db:
condition: service_healthy
dawarich_redis:
condition: service_healthyCreate the required directories and start the stack:
mkdir db_data db_shared redis_data public watched storage
docker compose up -dMonitor the startup process:
docker compose logs -fOnce all four containers are running (dawarich_db, dawarich_redis, dawarich_app, dawarich_sidekiq), access Dawarich at http://localhost:3000 with default credentials email: [email protected] and password: password. Change this password immediately after first login.
Critical configuration variables
Several environment variables require careful attention. APPLICATION_HOSTS must list all domains or IP addresses you’ll use to access Dawarich, without http:// or https:// prefixes. For example: localhost,127.0.0.1,dawarich.example.com. Misconfiguration causes “Blocked Host” errors.
Keep APPLICATION_PROTOCOL set to http even when using an HTTPS reverse proxy like Caddy or Nginx. The proxy handles SSL termination while internal health checks need HTTP. Setting this to https breaks container health monitoring.
The TIME_ZONE variable uses IANA timezone format like America/New_York or Europe/London. This affects how timestamps display throughout the interface.
Getting started: your first steps with Dawarich
After installation, your immediate tasks are security and data import. Navigate to Settings by clicking your email address in the top right corner, then change the default password under the Account section. Locate your API key here as well – you’ll need it for mobile app configuration and integrations.
Setting up mobile tracking
Dawarich supports multiple mobile applications for real-time location tracking. The official Dawarich iOS app provides the simplest setup: install from the App Store, open Settings in the app, enter your API key, and tap Save. The app immediately begins tracking in the background.
For OwnTracks (available on iOS and Android), open the app, tap the information icon in the top left, navigate to Settings, select HTTP mode, and enter this URL: http://your-instance:3000/api/v1/owntracks/points?api_key=YOUR_API_KEY. Choose between Significant mode (battery-friendly, updates every 5 minutes with significant movement) or Move mode (continuous tracking with high accuracy but heavy battery drain).
Overland for iOS uses a similar configuration. Open the app, go to Settings, slide to unlock, tap “Receiver Endpoint URL,” and paste: http://your-instance:3000/api/v1/overland/batches?api_key=YOUR_API_KEY.
Android users can configure GPSLogger with more detailed settings including custom HTTP body JSON and headers, providing fine-grained control over what data gets transmitted.
Importing your Google Timeline history
Most users want to import years of historical data from Google Timeline. Google provides two main export methods with different characteristics.
For Google Takeout (web export), request your location history data at Google Takeout, selecting only Location History. Download the resulting ZIP file containing monthly JSON files with semantic location data (addresses, place names, activity types). In Dawarich, navigate to Imports → New Import, select “Google Semantic History” as the source, upload multiple monthly JSON files simultaneously, and click Create Import. Processing runs in the background, typically completing within seconds to minutes depending on file size.
The Records.json file from Google Takeout contains more raw data points but is too large for web upload (often exceeding 5MB). For this file, use the command-line approach:
# Copy file to server
scp Records.json user@server:/path/to/dawarich/
# Copy into container
docker cp Records.json dawarich_app:/var/app/tmp/imports/Records.json
# Execute import command
docker exec -it dawarich_app sh
bundle exec rake import:big_file['tmp/imports/Records.json','[email protected]']Monitor the import progress at http://your-instance:3000/sidekiq.
For post-2024 phone exports, Google moved Timeline data to device-only storage. Export from your Android or iPhone (Settings → Location → Timeline → Export Timeline data), generating a timeline.json file. Import this via the web interface selecting “Google Phone Takeout” as the source.
Advanced features: photos, trips, and family sharing
Integrating your photo library
Dawarich’s photo integration stands out as a unique feature. Navigate to Settings and find the Photo Integration section. For Immich integration, enter your Immich instance URL and API key (generated in Immich with asset.read scope). For Photoprism, provide your instance URL and API key from Settings → Account → Apps and Devices.
After saving credentials, click “Import Immich data” or “Import Photoprism data” on the Imports page. Dawarich extracts GPS coordinates from photo EXIF data in the background. Enable the Photos layer on the map (toggle in top right corner) to see camera markers at exact capture locations. Photos automatically appear in trip views for relevant date ranges, creating visual travel journals.
Creating and managing trips
Trips transform raw location data into meaningful travel documentation. Click Trips in the navigation menu, then New Trip. Enter a descriptive name like “Iceland Adventure 2024,” set start and end dates, and optionally add notes. Dawarich automatically calculates the route between all points in that date range, computes total distance traveled, shows duration, displays the path on an interactive map, and if photo integration is active, presents all images taken during those dates.
This feature particularly benefits travel photographers, digital nomads, and anyone wanting to document journeys with precision. Unlike Google Timeline which lacks dedicated trip creation, Dawarich makes it a first-class feature.
Family location sharing
Version 0.34.0 introduced consensual family location sharing. Navigate to Family settings and create a family group, then invite members by email. Each family member controls their own sharing settings, choosing to share for 1, 6, 12, or 24 hours. The permanent sharing option was intentionally removed for privacy reasons.
Enable the “Family members” layer on your map to see real-time locations of family members who’ve opted in. This provides a privacy-respecting Life360 alternative where sharing is consensual, controlled by each individual, running on infrastructure you own, with no corporate surveillance or data monetization.
Understanding the technical architecture
Dawarich leverages modern Ruby on Rails architecture. Built with Ruby 3.4.6 and Rails 8.0, the application uses Hotwire (Turbo and Stimulus) for reactive frontend experiences without heavy JavaScript frameworks. The Turbo Rails library enables page navigation and partial updates without full reloads, while Stimulus adds minimal JavaScript sprinkles for interactivity.
The backend relies on PostgreSQL 17 with PostGIS 3.5 extensions for spatial data storage, enabling efficient geographic queries and calculations. Redis 7.4 handles caching via ActionCable and job queuing for Sidekiq, which processes background tasks like imports, reverse geocoding, and statistics calculations.
The architecture deploys as four containerized services: the web application serving the UI and API, Sidekiq workers processing asynchronous jobs, PostgreSQL providing data persistence, and Redis managing cache and queues. This separation allows independent scaling – you can run multiple Sidekiq workers for heavy import processing while keeping a single web instance.
API access and automation
Dawarich exposes a RESTful API at /api/v1/ endpoints, documented interactively at /api-docs. Authentication uses API keys found in account settings, passed as query parameters ?api_key=YOUR_KEY or as Bearer tokens in Authorization headers.
Key endpoints include POST /api/v1/owntracks/points for receiving location updates from mobile apps, GET /api/v1/points for retrieving tracked locations with pagination, GET /api/v1/photos for accessing photo collections when integration is enabled, and GET /api/v1/health for monitoring service status. This API enables custom integrations, Home Assistant automation, and programmatic data access.
Troubleshooting common issues and getting help
The most critical advice: never update automatically. Dawarich is under heavy development with frequent breaking changes. Always read release notes at the GitHub repository before updating, backup your database first, and verify Sidekiq queues are empty at /sidekiq before proceeding.
Frequently encountered problems
- Blocked Host errors occur when
APPLICATION_HOSTSdoesn’t include your domain or IP. Edit your docker-compose.yml to add the hostname without protocol prefixes, then restart withdocker compose down && docker compose up -d. - Health check failures became common after version 0.26.4 when
wgetwas removed from containers. Update your docker-compose.yml health check commands to use the exact syntax shown in the installation section above. - Database migration issues present the most complex challenges. The PostgreSQL 14 to 17 migration required by version 0.26.0 is not backwards compatible. Follow the official migration guide at dawarich.app/docs/tutorials/update-postgresql/, which involves running both databases simultaneously, creating dumps, and carefully restoring to the new version.
- Container connectivity problems on Synology NAS and similar platforms often stem from network configuration. Ensure all services use the same Docker network, verify DATABASE_HOST matches the container name (dawarich_db), and check that REDIS_URL follows the format
redis://dawarich_redis:6379/0.
Where to get help
The Dawarich community offers excellent support through multiple channels. The Discord server at discord.com/invite/pHsBjpt5J8 hosts over 700 active members and provides the fastest real-time help. The Discourse forum at discourse.dawarich.app handles longer discussions and feature requests. GitHub Issues at github.com/Freika/dawarich/issues is best for bug reports with very responsive maintainer engagement.
The official documentation at dawarich.app/docs/ includes comprehensive installation guides, update procedures with version-specific instructions, troubleshooting FAQs, and platform-specific setup for Synology, Unraid, and TrueNAS systems.
Alternatives and related tools
While Dawarich offers the most comprehensive feature set for Google Timeline replacement, several alternatives exist. OwnTracks provides more mature, stable tracking with fewer features. Traccar focuses on GPS device and fleet tracking with support for 200+ protocols. PhoneTrack integrates with Nextcloud for web-based tracking. Each serves different priorities – choose Dawarich for features and active development, OwnTracks for stability, or Traccar for device diversity.
For users wanting the Dawarich experience without self-hosting complexity, Dawarich Cloud offers managed hosting at €15/month with automatic updates, backups, and priority support running on GDPR-compliant European servers.
Best practices for long-term success
Establish a regular backup routine before anything else. Export your database weekly with:
docker compose exec dawarich_db pg_dumpall --clean --if-exists --username=postgres | gzip > backup_$(date +%Y%m%d).sql.gzNever delete your original Google Takeout data after importing. Keep multiple backups across different locations.
For reverse geocoding to convert GPS coordinates into street addresses, configure either the free Photon API (limited to 1 request per second), Geoapify (free tier available), or deploy your own Photon instance for unlimited usage. Set these via environment variables:
environment:
PHOTON_API_HOST: photon.yourdomain.com
PHOTON_API_USE_HTTPS: true
# or
GEOAPIFY_API_KEY: your_key_hereMonitor resource usage and adjust BACKGROUND_PROCESSING_CONCURRENCY if needed. The default of 10 Sidekiq threads works well for most installations, but memory-constrained systems should reduce this to 1 or 2.
Subscribe to GitHub release notifications to stay informed about updates. Join the Discord server for community discussions about upcoming features and breaking changes. Consider sponsoring development through Patreon at patreon.com/freika or GitHub Sponsors if you find value in the project.
Looking ahead: the future of self-hosted location tracking
Dawarich represents a paradigm shift in how we think about location data. By combining comprehensive tracking, beautiful visualization, seamless photo integration, consensual family sharing, and uncompromising privacy principles, it demonstrates that users don’t need to sacrifice functionality for data sovereignty.
The project’s rapid growth – from initial release to 7,100+ GitHub stars in under two years – signals strong demand for privacy-respecting alternatives to commercial services. As Google and other tech companies increasingly restrict user access to their own data, self-hosted solutions like Dawarich become not just appealing but necessary for maintaining control over digital life records.
While the active development means occasional breaking changes and troubleshooting needs, the tradeoff brings rapid feature improvements, responsive community support, and the knowledge that your location history remains permanently under your control. For privacy-conscious users, digital nomads, travel photographers, families seeking Life360 alternatives, and the broader self-hosting community, Dawarich offers a compelling path forward for location tracking that respects both functionality needs and fundamental privacy rights.
