Pixelfed vs Lychee: Self-Hosted Photo Platforms Compared

Quick Verdict

Pixelfed and Lychee solve fundamentally different problems. Pixelfed is a federated Instagram replacement — social photo sharing with followers, likes, comments, stories, and ActivityPub federation across the fediverse. Lychee is a private photo gallery — a beautiful way to organize, browse, and selectively share your photo collection without any social features. If you want to share photos publicly and build a following, use Pixelfed. If you want a private gallery to manage and showcase your photos, use Lychee.

Overview

Pixelfed is an open-source, federated photo sharing platform built on Laravel. It implements the ActivityPub protocol, meaning your Pixelfed instance can interact with Mastodon, Pleroma, and other fediverse services. Users post photos, follow other users (locally or on remote instances), like, comment, and share stories. It is a direct Instagram replacement for people who want social photo sharing without the surveillance capitalism.

Lychee is an open-source photo management and gallery application, also built on Laravel. It focuses on organizing photos into albums, displaying EXIF metadata, generating thumbnails, and providing clean sharing links. There are no followers, no feeds, no social interactions. It is a self-hosted Flickr or Google Photos gallery — a place to store, organize, and optionally share beautiful photo albums.

Both are PHP/Laravel applications, but the similarity ends at the tech stack.

Feature Comparison

Feature	Pixelfed	Lychee
Primary purpose	Social photo sharing	Photo gallery and management
ActivityPub federation	Yes — full fediverse support	No
Followers and feeds	Yes — follow users locally and across instances	No
Likes and comments	Yes	No
Stories	Yes — ephemeral content like Instagram	No
Collections/Albums	Collections (curated groups of posts)	Albums with nested sub-albums
Hashtags and discovery	Yes — hashtag search, explore page, trending	No
EXIF metadata display	Basic	Full EXIF/IPTC display with map integration
Sharing model	Public posts, unlisted, followers-only, direct	Public albums, password-protected albums, hidden albums
User registration	Multi-user with registration controls	Multi-user with role-based access
Mobile app	Official Android/iOS apps	Responsive web UI, no native app
License	AGPL-3.0	MIT
Database support	PostgreSQL or MySQL	MySQL, PostgreSQL, or SQLite
RAM usage (idle)	~300 MB+	~100 MB
Docker image	pixelfed/pixelfed:0.12.5	lycheeorg/lychee:v5.6.1
Bulk upload	Yes	Yes — drag and drop, supports ZIP import
API	REST API (Mastodon-compatible)	REST API
Video support	Yes — short video clips	Limited — photo-focused
Import from Instagram	Yes — official import tool	No

Installation Complexity

Pixelfed

Pixelfed requires PostgreSQL (or MySQL), Redis for queuing and caching, and a background worker process (Horizon). The Docker setup is more involved because you need to manage the web server, worker, scheduler, and dependencies. Initial setup includes running database migrations, creating an admin account, and configuring federation settings.

Create a docker-compose.yml:

services:
  pixelfed:
    image: pixelfed/pixelfed:0.12.5
    container_name: pixelfed-web
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - pixelfed-storage:/var/www/storage
      - pixelfed-bootstrap:/var/www/bootstrap
    environment:
      # App settings
      - APP_NAME=Pixelfed
      - APP_ENV=production
      - APP_DEBUG=false
      - APP_URL=https://pixelfed.example.com
      - APP_KEY=base64:GENERATE_WITH_php_artisan_key_generate

      # Database
      - DB_CONNECTION=pgsql
      - DB_HOST=pixelfed-db
      - DB_PORT=5432
      - DB_DATABASE=pixelfed
      - DB_USERNAME=pixelfed
      - DB_PASSWORD=CHANGE_THIS_STRONG_PASSWORD

      # Redis
      - REDIS_HOST=pixelfed-redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=null

      # Cache and sessions
      - CACHE_DRIVER=redis
      - SESSION_DRIVER=redis
      - QUEUE_DRIVER=redis

      # Federation — enable ActivityPub
      - ACTIVITY_PUB=true
      - AP_REMOTE_FOLLOW=true
      - AP_INBOX=true
      - AP_OUTBOX=true
      - AP_SHAREDINBOX=true

      # Features
      - OPEN_REGISTRATION=false
      - ENFORCE_EMAIL_VERIFICATION=true
      - PF_MAX_USERS=1000

      # Storage
      - PF_ENABLE_CLOUD=false
      - FILESYSTEM_DRIVER=local

      # Mail — configure for email verification
      - MAIL_DRIVER=log
      - [email protected]
      - MAIL_FROM_NAME=Pixelfed

      # Image processing
      - IMAGE_DRIVER=imagick
    depends_on:
      - pixelfed-db
      - pixelfed-redis
    networks:
      - pixelfed-net

  pixelfed-worker:
    image: pixelfed/pixelfed:0.12.5
    container_name: pixelfed-worker
    restart: unless-stopped
    command: gosu www-data php artisan horizon
    volumes:
      - pixelfed-storage:/var/www/storage
      - pixelfed-bootstrap:/var/www/bootstrap
    environment:
      - APP_NAME=Pixelfed
      - APP_ENV=production
      - APP_DEBUG=false
      - APP_URL=https://pixelfed.example.com
      - APP_KEY=base64:GENERATE_WITH_php_artisan_key_generate
      - DB_CONNECTION=pgsql
      - DB_HOST=pixelfed-db
      - DB_PORT=5432
      - DB_DATABASE=pixelfed
      - DB_USERNAME=pixelfed
      - DB_PASSWORD=CHANGE_THIS_STRONG_PASSWORD
      - REDIS_HOST=pixelfed-redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=null
      - CACHE_DRIVER=redis
      - SESSION_DRIVER=redis
      - QUEUE_DRIVER=redis
      - ACTIVITY_PUB=true
    depends_on:
      - pixelfed-db
      - pixelfed-redis
    networks:
      - pixelfed-net

  pixelfed-db:
    image: postgres:16-alpine
    container_name: pixelfed-db
    restart: unless-stopped
    volumes:
      - pixelfed-db-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=pixelfed
      - POSTGRES_USER=pixelfed
      - POSTGRES_PASSWORD=CHANGE_THIS_STRONG_PASSWORD
    networks:
      - pixelfed-net

  pixelfed-redis:
    image: redis:7-alpine
    container_name: pixelfed-redis
    restart: unless-stopped
    volumes:
      - pixelfed-redis-data:/data
    networks:
      - pixelfed-net

volumes:
  pixelfed-storage:
  pixelfed-bootstrap:
  pixelfed-db-data:
  pixelfed-redis-data:

networks:
  pixelfed-net:

After starting with docker compose up -d, run the initial setup:

# Run database migrations
docker exec -it pixelfed-web php artisan migrate --force

# Create an admin account
docker exec -it pixelfed-web php artisan user:create

Lychee

Lychee is simpler to deploy. It needs a database (MySQL, PostgreSQL, or even SQLite for small setups) and nothing else. No Redis, no background workers, no scheduler. The web container handles everything.

Create a docker-compose.yml:

services:
  lychee:
    image: lycheeorg/lychee:v5.6.1
    container_name: lychee
    restart: unless-stopped
    ports:
      - "8090:80"
    volumes:
      - lychee-config:/conf
      - lychee-uploads:/uploads
      - lychee-sym:/sym
      - lychee-logs:/logs
    environment:
      # Database connection
      - DB_CONNECTION=mysql
      - DB_HOST=lychee-db
      - DB_PORT=3306
      - DB_DATABASE=lychee
      - DB_USERNAME=lychee
      - DB_PASSWORD=CHANGE_THIS_STRONG_PASSWORD

      # App settings
      - APP_URL=https://photos.example.com
      - APP_ENV=production
      - APP_DEBUG=false

      # Timezone
      - TIMEZONE=UTC

      # Trusted proxies for reverse proxy setups
      - TRUSTED_PROXIES=*
    depends_on:
      - lychee-db
    networks:
      - lychee-net

  lychee-db:
    image: mariadb:11-jammy
    container_name: lychee-db
    restart: unless-stopped
    volumes:
      - lychee-db-data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=CHANGE_THIS_ROOT_PASSWORD
      - MYSQL_DATABASE=lychee
      - MYSQL_USER=lychee
      - MYSQL_PASSWORD=CHANGE_THIS_STRONG_PASSWORD
    networks:
      - lychee-net

volumes:
  lychee-config:
  lychee-uploads:
  lychee-sym:
  lychee-logs:
  lychee-db-data:

networks:
  lychee-net:

Start it and navigate to the web UI:

docker compose up -d

Lychee handles database migrations automatically on first boot. You create your admin account through the web UI on first visit. That is it — no CLI commands, no additional setup steps.

Bottom line: Lychee is significantly easier to set up and maintain. Pixelfed has more moving parts because federation and social features require background processing infrastructure.

Performance and Resource Usage

Pixelfed is the heavier application. The web server, Horizon worker, PostgreSQL, and Redis add up. Expect around 300 MB of RAM at idle for the full stack, climbing under load as the worker processes federation jobs and image processing tasks. The worker process is particularly important — if it falls behind, federation delivery and image optimization stall.

Lychee is lightweight. The web container and a MySQL/MariaDB instance together consume around 100 MB at idle. Without background workers or federation overhead, resource usage stays predictable. Lychee generates thumbnails on upload and caches them, so the only CPU spikes happen during bulk imports.

Resource	Pixelfed	Lychee
RAM (idle)	~300 MB+	~100 MB
RAM (under load)	500 MB–1 GB+	150–300 MB
CPU	Moderate (image processing + federation)	Low (spikes during uploads only)
Disk	Photos + database + Redis	Photos + database
Background workers	Required (Horizon)	Not needed

Federation and Sharing Model

This is the fundamental difference between these two applications.

Pixelfed: Social by Default

Pixelfed is built around social interaction. Every photo you post goes into a feed. Other users — on your instance or across the fediverse — can follow you, like your posts, comment on them, and share them. You can follow Mastodon users and they can follow you back. Stories let you post ephemeral content. Hashtags make your photos discoverable. The explore page surfaces trending content.

Privacy controls exist (followers-only posts, direct messages), but the default mode is public sharing. Pixelfed assumes you want people to see your photos.

Lychee: Private by Default

Lychee is private by default. You upload photos, organize them into albums, and browse them yourself. Sharing is opt-in: you can make specific albums public, protect them with passwords, or generate sharing links. There is no concept of followers, feeds, or discovery. Nobody sees your photos unless you explicitly share an album link.

This makes Lychee ideal for personal photo archives, family photo sharing (send a password-protected album link), or portfolio sites where you control exactly what is visible.

Which Model Fits?

• You want to replace Instagram: Pixelfed. The entire application is designed around public photo sharing with social features.
• You want to replace Google Photos as a private gallery: Lychee. Simple, private, organized.
• You want to share photos with family: Lychee. Password-protected albums are purpose-built for this.
• You want to participate in the fediverse: Pixelfed. Lychee has zero federation support.

Community and Support

Pixelfed has a larger community driven by the fediverse ecosystem. The GitHub repository is actively maintained by Daniel Supernault and contributors, with regular releases. Documentation exists but has gaps — some advanced configuration requires reading source code or community posts. The fediverse itself provides community support since Pixelfed users tend to be active on Mastodon.

Lychee has a smaller but focused community. Development is active with regular releases from the LycheeOrg team. Documentation is solid and covers most configuration options. The GitHub Discussions page and a small Discord server provide community support.

Both projects are healthy and actively maintained as of 2026.

Use Cases

Choose Pixelfed If…

• You want a self-hosted Instagram replacement with a social feed
• You want to participate in the fediverse and federate with Mastodon users
• You want public photo sharing with followers, likes, and comments
• You want stories and hashtag-based discovery
• You are migrating from Instagram and want to import your data
• You want to run a multi-user photo sharing community

Choose Lychee If…

• You want a private photo gallery to organize your collection
• You want to share specific albums with family or clients via links
• You want EXIF metadata display and map integration
• You prefer a lightweight deployment with minimal resource usage
• You do not need social features, followers, or federation
• You want SQLite support for a simple single-user setup
• You want a portfolio or photography showcase site

Final Verdict

These are not competing products — they solve different problems. Picking between them is straightforward.

Use Pixelfed if your goal is social photo sharing. It is the best self-hosted Instagram alternative, and ActivityPub federation gives it a network effect that no other self-hosted photo platform has. You post photos, people follow you, and the social graph extends across the entire fediverse. The trade-off is a more complex deployment and higher resource usage.

Use Lychee if your goal is a private photo gallery. It is clean, fast, lightweight, and does one thing well: organize and display your photos beautifully. Password-protected album sharing covers the family use case perfectly. You get a polished gallery without the overhead of social infrastructure you do not need.

If you want both — a private library for personal organization and a public presence for sharing — run both. They do not overlap. Or consider Immich, which sits between the two as a Google Photos replacement with AI-powered organization, mobile app backup, and sharing features without federation.

Related

• How to Self-Host Pixelfed
• How to Self-Host Lychee
• How to Self-Host Immich
• Best Self-Hosted Photo Management
• The Fediverse Explained
• Replace Google Photos
• Docker Compose Basics
• Reverse Proxy Setup