Dawarich Docker: Self-Hosted Google Timeline Replacement

Google quietly killed Timeline as a cloud feature in 2024 — your history now lives only on the device that recorded it, with no easy way to back it up, sync it, or analyze it across devices. If you ever pulled out Google Timeline to settle a “where were we in 2019?” debate, you’ve already noticed it’s not the same product. Dawarich brings that capability back, except you host it yourself, and Google never sees the data.

If you already self-host tools like Immich for photos, Home Assistant for device presence, or AdventureLog for trips, Dawarich is the missing timeline layer: it turns raw GPS pings into a searchable map history you control.

What is Dawarich?

Dawarich is a self-hostable web app that tracks, visualizes, and analyzes your location history. It’s positioned as a direct replacement for Google Timeline (formerly Google Location History) — same use cases, none of the data flowing to a third party.

“Dawarich is a self-hostable web app designed to replace Google Timeline. Track your location history, visualize your data on an interactive map, create trips, share your location with family members, and integrate with photo management apps.”

Dawarich on GitHub Dawarich Website Dawarich Documentation

What you can do with it

• 🗺️ Interactive maps — heatmap, point cloud, lines, fog of war (the “where have I been” overlay)
• 📅 Trips — name a date range and Dawarich computes the route, distance, and time spent
• 🏡 Areas and visits — draw a polygon around a location, get visit detection (beta)
• 👪 Family sharing — share your live location with family members who also use Dawarich
• 📊 Statistics and insights — countries visited, cities visited, total distance, days per country (handy for tax residency tracking)
• 🖼️ Photo integration — connect Immich or Photoprism and your geotagged photos appear on the map
• 📥 Import everywhere from — Google Takeout, OwnTracks, Strava, Immich, GPX, GeoJSON, photo EXIF
• 📤 Export anywhere to — GeoJSON, GPX
• 🌐 Public sharing — share a specific month’s stats with a UUID link that expires after a configurable window
• ⚖️ AGPL-3.0 — fully open source

How tracking works

Dawarich doesn’t include a built-in mobile tracker — instead it accepts pings from any OwnTracks-compatible app (or its own iOS/Android apps). You configure the tracker with your Dawarich URL + API key, and it POSTs location updates whenever your phone moves enough to be worth recording.

Tech Stack in Brief

Backend: Ruby on Rails 8.0, PostgreSQL 17 + PostGIS 3.5, Sidekiq + Redis for background jobs, Devise for auth, Pundit for authorization. PostGIS is doing the heavy lifting — distance queries, point-in-polygon for visit detection, hexagon binning for the heatmap, all done as spatial SQL instead of Ruby loops.

Frontend: Hotwire (Turbo + Stimulus) + Tailwind CSS + DaisyUI. Direct JavaScript only for the map layer — Leaflet (v1 maps) and MapLibre GL JS (v2 maps). No React, no Vue, no SPA bundling.

Imports: Background-processed by Sidekiq. A 5-year Google Takeout archive can take hours to import — kick it off and walk away.

Self-Hosting Dawarich with Docker

Docker Compose

Four containers: app, sidekiq worker, Postgres-with-PostGIS, and Redis. The compose below is adapted from docker/docker-compose.yml in the repo:

networks:
  dawarich:

services:
  dawarich_redis:
    image: redis:7.4-alpine
    container_name: dawarich_redis
    command: redis-server --save 900 1 --save 300 10 --appendonly no
    networks: [dawarich]
    volumes:
      - dawarich_shared:/data
    restart: always

  dawarich_db:
    image: postgis/postgis:17-3.5-alpine
    # ARM hosts (Raspberry Pi, ARM VMs): use imresamu/postgis:17-3.5-alpine
    shm_size: 1G
    container_name: dawarich_db
    volumes:
      - dawarich_db_data:/var/lib/postgresql/data
    networks: [dawarich]
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: changeme
      POSTGRES_DB: dawarich_production
    restart: always

  dawarich_app:
    image: freikin/dawarich:latest
    container_name: dawarich_app
    ports:
      - "3000:3000"
    volumes:
      - dawarich_storage:/var/app/storage
      - dawarich_public:/var/app/public
      - dawarich_watched:/var/app/tmp/imports/watched
    networks: [dawarich]
    entrypoint: web-entrypoint.sh
    command: ['bin/rails', 'server', '-p', '3000', '-b', '::']
    environment:
      RAILS_ENV: production
      REDIS_URL: redis://dawarich_redis:6379
      DATABASE_HOST: dawarich_db
      DATABASE_USERNAME: postgres
      DATABASE_PASSWORD: changeme
      DATABASE_NAME: dawarich_production
      APPLICATION_HOSTS: localhost,dawarich.example.com
      APPLICATION_PROTOCOL: https
      SECRET_KEY_BASE: REPLACE_WITH_64_HEX_BYTES   # generate: openssl rand -hex 64
      SELF_HOSTED: 'true'
      STORE_GEODATA: 'true'
      TIME_ZONE: Europe/London
    restart: on-failure

  dawarich_sidekiq:
    image: freikin/dawarich:latest
    container_name: dawarich_sidekiq
    volumes:
      - dawarich_storage:/var/app/storage
      - dawarich_watched:/var/app/tmp/imports/watched
    networks: [dawarich]
    entrypoint: sidekiq-entrypoint.sh
    command: ['sidekiq']
    environment:
      RAILS_ENV: production
      REDIS_URL: redis://dawarich_redis:6379
      DATABASE_HOST: dawarich_db
      DATABASE_USERNAME: postgres
      DATABASE_PASSWORD: changeme
      DATABASE_NAME: dawarich_production
      SECRET_KEY_BASE: REPLACE_WITH_64_HEX_BYTES
      SELF_HOSTED: 'true'
      BACKGROUND_PROCESSING_CONCURRENCY: 5
    restart: on-failure

volumes:
  dawarich_db_data:
  dawarich_shared:
  dawarich_public:
  dawarich_watched:
  dawarich_storage:

After docker compose up -d, open http://localhost:3000 and log in with the default credentials below. Change them immediately.

Default credentials: [email protected] / safepassword

  dawarich_db:
    image: imresamu/postgis:17-3.5-alpine

    environment:
      OTP_ENCRYPTION_PRIMARY_KEY: <hex>
      OTP_ENCRYPTION_DETERMINISTIC_KEY: <hex>
      OTP_ENCRYPTION_KEY_DERIVATION_SALT: <hex>

Exposing Dawarich Safely

Dawarich contains sensitive location history, so do not expose it casually. For home labs, I would treat it like a private admin app:

• Keep it LAN-only if you only need access from home.
• Put it behind a VPN such as Tailscale or Headscale when you need mobile access.
• Use Cloudflare Tunnel or Pangolin only with authentication in front.
• Terminate HTTPS with Traefik, Caddy, or Nginx Proxy Manager if you expose it through a domain.

The data is more personal than a normal dashboard. Use 2FA, make backups, and avoid public registration.

Update Strategy (Important)

The project’s README ships an explicit warning: do not auto-update Dawarich. The codebase is under active development, releases include schema migrations, and a bad migration on top of unbacked-up data can lose history.

The recommended flow on every upgrade:

1. Read the release notes for every version between yours and latest
2. Back up the dawarich_db_data volume (Postgres dump or volume snapshot)
3. Pull the new image and docker compose up -d
4. Watch logs until migrations finish before claiming success

Watchtower / auto-updaters are explicitly discouraged for this project.

Dawarich vs the Alternatives

The honest read: if you only need a backend to receive OwnTracks pings, OwnTracks Recorder is leaner. Home Assistant can do basic device_tracker history if you already run it. But for a Google Timeline-replacement experience — heatmap, fog of war, trips, statistics, photo integration — Dawarich is the only self-hosted option that comes close.

Conclusion

Dawarich fills a niche that became a hole when Google killed Timeline as a cloud product: a self-hosted location history app that actually looks and feels modern. The Rails 8 + PostGIS architecture is solid, the import pipeline accepts everything you’d reasonably have (including years of Google Takeout JSON), and the family sharing + Immich/Photoprism integrations push it past “just a tracker” into “actual replacement.”

It’s still actively developed and the maintainer warns clearly about breaking changes — treat it like the early-stage project it is, back up before every upgrade, and you’ll have a working Timeline replacement on your own hardware.

Related tools worth knowing:

• OwnTracks — the reference protocol for self-hosted location tracking; minimal backend, no fancy UI
• OwnTracks Recorder — lightweight OwnTracks backend in C; pairs with OwnTracks apps but no maps UI
• Traccar — fleet-oriented GPS server; more commercial-feeling but mature
• Immich — self-hosted photo library; pairs with Dawarich for geotagged photo visualization