LibrePhotos vs Immich vs PhotoPrism: Best Self-Hosted Photo Management 2026

Managing a growing photo library without surrendering your memories to Google Photos or iCloud is one of the most compelling reasons to self-host. In 2026, three open-source platforms dominate this space: LibrePhotos, Immich, and PhotoPrism. Each takes a different architectural approach, targets a different user profile, and offers unique trade-offs between performance, features, and hardware requirements.

This guide compares all three platforms head-to-head, including real Docker Compose configurations, feature breakdowns, and step-by-step deployment instructions so you can choose the right solution for your home server.

Why Self-Host Your Photo Library?

Cloud photo services are convenient, but they come with significant trade-offs:

• Privacy concerns: Your photos are scanned, indexed, and potentially used for training by the service provider.
• Subscription costs: 2TB Google One plans cost $10/month — $120/year indefinitely.
• Vendor lock-in: Exporting tens of thousands of photos from Google Takeout is slow and metadata-lossy.
• Full control: Self-hosted solutions run on your hardware, with your storage, under your terms.
• Offline access: Your library is always available on your local network, regardless of internet connectivity.

All three platforms reviewed here run entirely on your own infrastructure — whether that’s a NAS, a home server, or a rented VPS.

Project Overview

Immich — The Google Photos Replacement

Immich is the fastest-growing self-hosted photo platform, with over 98,700 GitHub stars as of April 2026. Written primarily in TypeScript, it offers a near pixel-perfect Google Photos clone experience, complete with a mobile app that auto-backups your camera roll. Immich uses PostgreSQL with the VectorChord extension for semantic search, Valkey for caching, and a dedicated machine learning container for face recognition and image classification.

PhotoPrism — The Polished Gallery

PhotoPrism has been around since 2018 and is written in Go with a Vue.js frontend. With nearly 39,600 stars, it emphasizes photo quality, metadata preservation, and a polished browsing experience. PhotoPrism uses TensorFlow for image classification and face detection, and it supports a wide range of formats including RAW, HEIC, and Live Photos.

LibrePhotos — The Lightweight Alternative

LibrePhotos is the lightest of the three, with approximately 8,000 stars. Written in Python, it focuses on core functionality: automatic photo organization, timeline browsing, and face clustering. LibrePhotos uses PostgreSQL and Memcached, with a simpler architecture that requires fewer resources — making it ideal for lower-powered hardware like a Raspberry Pi 4.

Feature Comparison

Docker Compose Deployment

LibrePhotos

LibrePhotos provides the simplest Docker Compose setup. The official docker-compose.yml is available at the root of the repository:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# docker-compose.yml — LibrePhotos
version: '3.8'

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: ownphotos
      POSTGRES_USER: ownphotos
      POSTGRES_PASSWORD: ownphotos123
    volumes:
      - postgres-data:/var/lib/postgresql/data

  redis:
    image: redis:7

  backend:
    image: librephotos/librephotos
    depends_on:
      - db
      - redis
    environment:
      POSTGRES_DB: ownphotos
      POSTGRES_USER: ownphotos
      POSTGRES_PASSWORD: ownphotos123
    volumes:
      - ./data:/data
      - /mnt/photos:/protected_media:ro
      - /mnt/photos-upload:/scan_folder
    ports:
      - "8001:8001"

  frontend:
    image: librephotos/librephotos-frontend
    depends_on:
      - backend
    ports:
      - "3000:80"

volumes:
  postgres-data:

Start the stack with:

1

docker compose up -d

Access the web interface at http://your-server:3000. Point the scan_folder volume to your existing photo directory, and LibrePhotos will begin indexing automatically.

Immich

Immich requires a multi-container setup with a server, machine learning worker, PostgreSQL (with VectorChord), and Valkey. The official compose file is provided via each release:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# docker-compose.yml — Immich
name: immich

services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:release
    volumes:
      - ${UPLOAD_LOCATION}:/data
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - .env
    ports:
      - '2283:2283'
    depends_on:
      - redis
      - database
    restart: always

  immich-machine-learning:
    image: ghcr.io/immich-app/immich-machine-learning:release
    volumes:
      - model-cache:/cache
    env_file:
      - .env
    restart: always

  redis:
    image: docker.io/valkey/valkey:9

  database:
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
    volumes:
      - ${DB_DATA_LOCATION}:/var/lib/postgresql/data
    shm_size: 128mb
    restart: always

volumes:
  model-cache:

Create an accompanying .env file:

1
2
3
4
5
6
7

# .env — Immich
DB_PASSWORD=your-secure-db-password
DB_USERNAME=immich
DB_DATABASE_NAME=immich
UPLOAD_LOCATION=./immich-library
DB_DATA_LOCATION=./immich-postgres
IMMICH_VERSION=release

Start with:

1

docker compose up -d

Access at http://your-server:2283. Install the Immich mobile app from the App Store or Play Store, point it to your server URL, and enable automatic camera roll backup.

PhotoPrism

PhotoPrism uses an installer-based approach but also supports manual Docker Compose deployment. Here is a working compose configuration based on the official documentation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# docker-compose.yml — PhotoPrism
version: '3.5'

services:
  photoprism:
    image: photoprism/photoprism:latest
    depends_on:
      - mariadb
    security_opt:
      - seccomp:unconfined
      - apparmor:unconfined
    ports:
      - "2342:2342"
    environment:
      PHOTOPRISM_ADMIN_PASSWORD: "insecure-admin-password"
      PHOTOPRISM_DATABASE_DRIVER: "mysql"
      PHOTOPRISM_DATABASE_SERVER: "mariadb:3306"
      PHOTOPRISM_DATABASE_NAME: "photoprism"
      PHOTOPRISM_DATABASE_USER: "photoprism"
      PHOTOPRISM_DATABASE_PASSWORD: "insecure-db-password"
      PHOTOPRISM_ORIGINALS_LIMIT: "5000"
    volumes:
      - "./photoprism-storage:/photoprism/storage"
      - "/mnt/photos:/photoprism/originals:ro"
    restart: unless-stopped

  mariadb:
    image: mariadb:11
    security_opt:
      - seccomp:unconfined
      - apparmor:unconfined
    command: "mysqld --innodb-buffer-pool-size=2G --transaction-isolation=READ-COMMITTED"
    environment:
      MARIADB_DATABASE: "photoprism"
      MARIADB_USER: "photoprism"
      MARIADB_PASSWORD: "insecure-db-password"
      MARIADB_ROOT_PASSWORD: "insecure-root-password"
    volumes:
      - "./mariadb-data:/var/lib/mysql"
    restart: unless-stopped

Start with:

1

docker compose up -d

Access at http://your-server:2342. PhotoPrism will begin indexing files from the mounted originals directory. The first scan includes ML-based classification, so expect higher CPU usage initially.

Performance and Hardware Requirements

For libraries under 20,000 photos, all three perform well on a modest server. Immich’s dedicated ML container gives it the most resource-intensive baseline, but also delivers the fastest face recognition and semantic search results. PhotoPrism’s ML processing runs in-process, which simplifies deployment but can cause occasional slowdowns during heavy indexing. LibrePhotos, with its Python backend and simpler architecture, is the most forgiving on resources.

Which Should You Choose?

Choose LibrePhotos if:

• You have limited hardware (Raspberry Pi, low-end VPS)
• You want a simple, straightforward setup
• You don’t need a mobile app
• Your library is under 50,000 photos

Choose Immich if:

• You want the closest experience to Google Photos
• You need automatic mobile backup with a native app
• You have at least 4 GB RAM and a modern CPU
• You want the most active development community

Choose PhotoPrism if:

• You prioritize photo quality and metadata preservation
• You work with RAW files and need extensive format support
• You prefer a polished, gallery-first browsing experience
• You want a mature, stable platform with years of development history

For related reading, see our guide to self-hosted image galleries with Piwigo, Lychee, and Chevereto and our comparison of Immich vs PhotoPrism for a deeper two-way comparison. If you’re planning your storage backend, our NAS solutions guide covers the hardware side.

FAQ

Can I migrate from Google Photos to these platforms?

Yes. All three platforms support importing photos from local directories. For Google Photos, use Google Takeout to export your library, then place the extracted files in the scan/import directory of your chosen platform. Immich has the most streamlined import process with its mobile app backup feature.

Do these platforms support RAW camera files?

PhotoPrism has the most extensive RAW support, covering formats from Canon, Nikon, Sony, Fujifilm, and others. Immich supports most common RAW formats. LibrePhotos has limited RAW support — it will store RAW files but may not generate previews for all formats.

Can multiple users have separate photo libraries?

LibrePhotos and Immich both support multi-user setups with separate libraries and permissions. PhotoPrism supports multiple users but operates primarily as a single-admin system where the admin manages the shared library.

How much disk space do I need?

Plan for the same disk space as your original photo library, plus 10-20% overhead for thumbnails, cached ML data, and database files. For a 50 GB photo library, allocate approximately 60 GB of storage. Immich requires the most additional space due to its vector database and model cache.

Can I run these behind a reverse proxy?

Yes. All three platforms work behind reverse proxies like Nginx, Caddy, or Traefik. Simply proxy the web interface port (3000 for LibrePhotos, 2283 for Immich, 2342 for PhotoPrism) and configure WebSocket support for Immich’s real-time features.

Do these platforms work on ARM/Raspberry Pi?

LibrePhotos runs well on a Raspberry Pi 4 with 4 GB RAM. Immich has ARM64 images but ML processing is significantly slower on ARM. PhotoPrism works on ARM when using SQLite mode instead of MariaDB.