Reitti sits in the same broad category as Dawarich and GeoPulse: private location history you control yourself.

But it is not just a GPS point bucket. Reitti turns movement data into a timeline with visits, trips, significant places, raw tracks, cleanup tools, live sharing, federation-style sharing between instances, magic links, map styles, statistics, and Immich photo context.

That makes it a serious self-hosted Google Timeline replacement, and a useful companion to travel tools like AirTrail and AdventureLog.

Reitti = Spring Boot + PostGIS + Redis + tile cache + GPS timeline UI

What is Reitti?

The repository I checked was:

Repository: https://github.com/dedicatedcode/reitti
Checked commit: a65299fe11a8c3d3373bd04fa32a9dc2d3efa17f
Commit date: 2026-10-09
Latest checked release line: v5.x
Container image tested: docker.io/dedicatedcode/reitti:5
License: AGPL-3.0
Backend: Java 25, Spring Boot 4.1, Spring MVC, Spring Security
Database: PostgreSQL 17 + PostGIS 3.5
Cache: Redis
Jobs: Quartz

The name comes from Finnish and means “route” or “path”. That fits the product: Reitti is less about planning a single trip and more about understanding your long-term movement history.

Why It Is Interesting

The self-hosted travel/location stack is splitting into a few clear jobs:

Need Tool
Continuous GPS history Reitti, Dawarich, GeoPulse
Flight history AirTrail
Trip planning and travel journal AdventureLog
Photo library with locations Immich, PhotoPrism
Raw tracker protocol OwnTracks, GPSLogger, Overland

Reitti belongs in the first row.

It accepts live updates from mobile trackers and imports old data, then processes the points into a human timeline: where you stayed, how you moved, which places matter, and what changed across days or trips.

Features

Reitti’s README and source show support for:

  • interactive daily timeline;
  • visit and trip detection;
  • transport-mode handling;
  • significant places;
  • raw GPS tracks;
  • multi-user map view;
  • live sharing with same-instance users;
  • Reitti-to-Reitti sharing between trusted instances;
  • magic links for temporary live location sharing;
  • multiple devices per user;
  • workbench cleanup for moving/deleting/stitching points;
  • custom map styles;
  • GPX, FIT, GeoJSON, Google Takeout, Google Timeline export imports;
  • OwnTracks, GPSLogger, Overland, Home Assistant, MQTT, and REST API ingestion;
  • Immich photo integration;
  • statistics and summaries;
  • OIDC / single sign-on support.

That is a lot of surface area, but the center is still simple:

phone/app/import -> Reitti ingest -> PostGIS -> timeline/map/statistics

Self-Hosting Reitti with Docker

I updated the Home-Lab compose here:

Home-Lab Reitti compose

The current setup exposes Reitti on port 3814:

services:
  reitti:
    image: docker.io/dedicatedcode/reitti:${REITTI_VERSION:-5}
    container_name: reitti
    restart: unless-stopped
    ports:
      - ${REITTI_BIND:-0.0.0.0}:${REITTI_PORT:-3814}:8080
    depends_on:
      postgis:
        condition: service_healthy
      redis:
        condition: service_healthy
      tile-cache:
        condition: service_started
    volumes:
      - reitti-data:/data/
    environment:
      POSTGIS_USER: ${POSTGIS_USER:-reitti}
      POSTGIS_PASSWORD: ${POSTGIS_PASSWORD:?Set POSTGIS_PASSWORD in .env}
      POSTGIS_DB: ${POSTGIS_DB:-reittidb}
      POSTGIS_HOST: postgis
      REDIS_HOST: redis
      TILES_CACHE: ${TILES_CACHE:-http://tile-cache}
      BASE_PATH: ${BASE_PATH:-/}
      ADVERTISE_URI: ${ADVERTISE_URI:-http://192.168.1.2:3814}
      OIDC_ENABLED: ${OIDC_ENABLED:-false}
      OIDC_ISSUER_URI: ${OIDC_ISSUER_URI:-}
      OIDC_CLIENT_ID: ${OIDC_CLIENT_ID:-}
      OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET:-}
      DANGEROUS_LIFE: ${DANGEROUS_LIFE:-false}
      SPATIAL_COVERAGE: ${SPATIAL_COVERAGE:-false}
      JAVA_OPTS: ${JAVA_OPTS:--Xmx768m -Xms256m}
    healthcheck:
      test: ["CMD-SHELL", "wget -qO- http://localhost:8080/actuator/health >/dev/null 2>&1 || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 10
      start_period: 90s
    networks:
      - reitti

  postgis:
    image: ${POSTGIS_IMAGE:-postgis/postgis:17-3.5-alpine}
    container_name: reitti-postgis
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGIS_USER:-reitti}
      POSTGRES_PASSWORD: ${POSTGIS_PASSWORD:?Set POSTGIS_PASSWORD in .env}
      POSTGRES_DB: ${POSTGIS_DB:-reittidb}
    volumes:
      - postgis-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGIS_USER:-reitti} -d ${POSTGIS_DB:-reittidb}"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - reitti

  redis:
    image: redis:7-alpine
    container_name: reitti-redis
    restart: unless-stopped
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - reitti

  tile-cache:
    image: docker.io/dedicatedcode/reitti-tile-cache:${REITTI_VERSION:-5}
    container_name: reitti-tile-cache
    restart: unless-stopped
    volumes:
      - tile-cache-data:/var/cache/nginx
    networks:
      - reitti

volumes:
  postgis-data:
  redis-data:
  reitti-data:
  tile-cache-data:

networks:
  reitti:
    ipam:
      config:
        - subnet: ${REITTI_SUBNET:-10.89.14.0/24}

Create your .env:

cd /home/jalcocert/Desktop/Home-Lab/reitti
cp .env.sample .env
openssl rand -base64 32

Put the generated value in:

POSTGIS_PASSWORD=replace-with-a-long-random-password

Then start:

docker compose up -d

Open:

http://192.168.1.2:3814

On a fresh instance, Reitti redirects to /setup and asks you to configure the first admin password.

Field Note: Local Test

I ran the current Docker stack locally with:

POSTGIS_PASSWORD="$(openssl rand -base64 24)" docker compose up -d

That means I did not write a real secret into .env; the running containers received a temporary shell-provided password.

The stack came up with:

reitti
reitti-postgis
reitti-redis
reitti-tile-cache

The app health endpoint returned:

{"groups":["liveness","readiness"],"status":"UP"}

The root URL returned a 302 redirect to:

/setup

The setup page rendered correctly at http://127.0.0.1:3814/setup, and the Docker health status became healthy for Reitti, PostGIS, Redis, and tile-cache.

One useful detail from the logs: first boot applied 133 Flyway migrations and started Quartz. That tells me Reitti is doing real schema-managed processing work, not just serving a static map UI.

After setup, I logged in through the UI with username admin and the password chosen during the initial setup. The Dawarich GPX import was then visible in Reitti’s timeline and map, confirming the complete path from authenticated upload to processed location data. The import contained 2,126 points and Reitti derived 103 visits and 102 trips from it.

Stack Notes

The old Home-Lab compose I had for Reitti included RabbitMQ and Photon. Upstream Reitti 5’s normal compose is simpler:

Service Required? Notes
Reitti Yes Spring Boot app and web UI
PostGIS Yes Spatial persistence and indexes
Redis Yes Cache/coordination
Tile cache Default compose Local cache for map tiles
Photon Optional Local geocoding can be useful, but indexes may use serious disk
OIDC provider Optional Only needed if you want SSO

For a homelab, I would start without Photon and only add local geocoding when you know you need it. Location apps already grow their database over time; do not add a geocoder index casually on a nearly-full disk.

Reitti vs Dawarich, AirTrail, and AdventureLog

Tool Best At How It Relates to Reitti
Dawarich Google Timeline replacement, official apps, trips, stats, photos, Rails/PostGIS stack Closest alternative. Both are AGPL and self-hosted location-history apps. Reitti feels especially strong around workbench cleanup, live sharing/magic links, multi-device stitching, and Java/Spring architecture.
GeoPulse Feature-rich location timeline, analytics, sharing, Quarkus/Vue/PostGIS Same broad category, but different license posture and architecture.
AirTrail Flight history and aviation stats Complementary. AirTrail records flights; Reitti records continuous ground/location history.
AdventureLog Trip planning, adventure logs, travel journal Complementary. AdventureLog is intentional travel planning/logging; Reitti is passive GPS history and analysis.

The simplest way to think about it:

Reitti / Dawarich / GeoPulse = where I actually went
AirTrail                    = which flights I took
AdventureLog                = what I planned, logged, and want to remember as a trip

For your homelab, Reitti and Dawarich overlap the most. AirTrail and AdventureLog do not really compete with Reitti; they add context around travel.

Safe Exposure

GPS history is sensitive. I would not expose Reitti casually.

Good patterns:

  • VPN-only access through Tailscale or WireGuard;
  • reverse proxy with HTTPS and strong auth;
  • Cloudflare Tunnel protected by Cloudflare Access;
  • OIDC login if you already run a provider.

If you expose it under a domain, set ADVERTISE_URI to the public URL so Reitti generates correct device/integration instructions.

Backups matter too. Back up:

PostGIS database volume
Reitti /data volume

Redis and tile cache can usually be rebuilt.

FAQ

Conclusion

Reitti is one of the most interesting self-hosted location-history apps I have tested so far.

It overlaps strongly with Dawarich, but the feeling is different: Java/Spring instead of Rails, current standard compose without RabbitMQ, a polished setup flow, a cleanup workbench, live sharing, magic links, and a clear timeline/map focus.

I would not replace AirTrail or AdventureLog with it. I would place Reitti beside them: Reitti for the actual GPS timeline, AirTrail for flight history, and AdventureLog for planned or remembered trips.