[opensourcedex]

home-gallery is a free, open source photo & video editors project written in JavaScript and released under MIT. It has 1,183 GitHub stars, 106 forks and 54 open issues, and was last pushed 3 months ago. On this registry it ranks #33 of 35 tracked projects in Photo & Video Editors, with 5 head-to-head comparisons available.

What is home-gallery?

HomeGallery is a self-hosted, MIT-licensed open-source web gallery for people who keep their photo and video archives on their own hardware and want a private, mobile-friendly way to browse them, including tagging and AI-powered image and face discovery.

What it is

HomeGallery is an open-source web application written in JavaScript and distributed under the MIT licence, whose source of truth is a personal media archive stored locally — on a NAS, a hard drive, camera exports, or files copied from a mobile phone. Instead of uploading that archive to a third party, it reads the files where they already live and builds a gallery on top of them. It is driven by a command-line interface named gallery, shipped either as a prebuilt binary or as the Docker image xemle/home-gallery, and it exposes its web interface on localhost:3000 by default. Fine tuning happens through a gallery.config.yml file, which is written to the current directory when using a binary and to ./data/config/ when using Docker.

The concrete problem it solves is stated plainly in the project's motivation: cloud services do not cover the author's privacy concerns, existing gallery software is slow to use on mobile phones, and a gallery should sit on top of or close to the media source while still helping users rediscover forgotten memories from a complete archive. HomeGallery therefore takes the place of a hosted photo service and of a conventional local gallery application, indexing local source directories, calculating previews, and serving the result to a browser.

Key capabilities

  • Serves a full personal archive from multiple media source directories, covering hard drives, camera files, and mobile phone files.
  • Provides a gallery CLI with commands such as gallery init --source ~/Pictures, gallery run server, and gallery -h for further help.
  • Ships as prebuilt binaries for Linux, macOS (darwin-x64), and Windows (win-x64), plus the Docker image xemle/home-gallery.
  • Calculates previews of images and videos so browsing stays fast.
  • Reads EXIF metadata and performs geo-reverse lookups to organise media by capture data and location.
  • Applies AI-powered discovery, including face detection and face recognition, and offers a similar-image view reachable at paths such as /similar/ as demonstrated by the demo gallery.
  • Supports tagging alongside a mobile-friendly browsing interface.

Who uses it and how

  • Computer-affine users who solve their own problems and go the extra mile, which is the project's own description of its target audience.
  • Single-user deployments: the gallery is intended for one user who is served all files, rather than for multi-account family sharing.
  • Self-hosters who want to serve local data without cloud services, typically keeping the archive on a NAS or attached drives.
  • Mobile users viewing their own photos and videos from a phone browser, one of the stated motivations for the project.
  • Docker users who mount a data directory and their picture directory as volumes, run gallery init --source /data/Pictures, then gallery run server, and open port 3000.

Getting started

Download a prebuilt binary for Linux, macOS, or Windows, or run the Docker image xemle/home-gallery, then initialise with ./gallery init --source ~/Pictures and start serving with ./gallery run server before opening http://localhost:3000 in a browser.

How it compares

The provided facts do not name any paid products that HomeGallery replaces, and they do not name comparable gallery tools either. On the evidence available here, it stands alone in this registry, and any product-by-product comparison would have to be drawn from the project's own documentation rather than from the material summarised on this page.

When to use it — and when not to

HomeGallery suits a single technical user who is willing to run a server, maintain a gallery.config.yml, and manage local source directories; the README describes it as a private pet and spare-time project supplied without any warranty, with questions directed to Gitter or Discord. Anyone who needs multi-user accounts, a managed service, or contractual support should look elsewhere, since the project is explicitly scoped to one user and offers only community help plus optional financial support through Patreon or PayPal. The trade-off is direct control and privacy in exchange for operating the tool yourself.

project readme (upstream, from github) — read inline

HomeGallery hero image

HomeGallery

Join the chat at https://gitter.im/home-gallery/community

Home-Gallery.org is a self-hosted open-source web gallery to browse personal photos and videos featuring tagging, mobile-friendly, and AI powered image and face discovery. Try the demo gallery or enjoy the food images!

Note: This software is a private pet/spare time project without any warranty. Ask questions on gitter.im or Discord.

Do you like HomeGallery? Does it solve your media problem? Would you like to help? Please read the CONTRIBUTING guidelines and support this project through any recurring financial support to my patreon.com/xemle or one time support to my paypal.me/xemle account. Thank you in advance.

MIT License

Links

Motivation

  • The source of all my private images and videos are stored local on my NAS at home. The gallery should be on top/close of the source.
  • Cloud service do not cover my privacy concerns
  • All gallery software are lacking to have a fast user experience on mobile phones
  • The gallery software should help to browse and discover forgotten memories from the complete media archive

Target Users

  • Computer affine users who solve their own problems and go the extra mile
  • Serve your local data without usage of cloud services
  • One user only - all files are served
  • View your own photos and videos from mobile phones
  • Serve all your images from multiple media source directories (hard drive, camera files, mobile phone files, etc)

Quickstart

Following steps need to be performed to use HomeGallery

  • Download the gallery software as prebuilt binary or docker image
  • Init the configuration with media sources like ~/Pictures
  • Start the server on localhost:3000
curl -sL https://dl.home-gallery.org/dist/latest/home-gallery-latest-linux-x64 -o gallery
chmod 755 gallery
./gallery init --source ~/Pictures
./gallery run server

and open localhost:3000 in your browser. Run ./gallery -h for further help of the CLI.

See dl.home-gallery.org/dist for further binaries. Eg. latest binaries for Linux, Mac or Windows.

The configuration gallery.config.yml can be found in the current directory for fine tuning. See install section in the documentation for further information.

Quickstart using Docker

mkdir -p data
alias gallery="docker run -ti --rm \
  -v $(pwd)/data:/data \
  -v $HOME/Pictures:/data/Pictures \
  -u $(id -u):$(id -g) \
  -p 3000:3000 xemle/home-gallery"
gallery init --source /data/Pictures
gallery run server

and open localhost:3000 in your browser. Run gallery -h for further help of the CLI.

The gallery configuration can be found in ./data/config/gallery.config.yml for fine tuning.

Want to use docker compose? See install section in the documentation for further information.

Documentation

See home-gallery.org/docs for general documentation.

Features

  • Endless photo stream via virtual scrolling
  • Video transcoding
  • Reverse image lookup (similar image search). If you have one sunset image, you can easily find other sunset photos in your archive without manual tagging
  • Face detection and search by similar faces
  • Expressive query language with and, or, not operands
  • GEO location reverse lookups
  • Simple mobile app through PWA support
  • Tagging, single and multi selection
  • Support of read only and offline media sources. Once the preview files are generated and their meta data are extracted, the original sources are not touched and required any more. So media from offline disk need to be extracted only once and the disk can stay offline on next runs
  • Media are identified by their content. Duplicated media (identical files byte-by-byte) are only processed once. Renaming is supported without recalculating previews etc.
  • Fast file changes detection such as add, removes, renames or moves
  • Static web gallery site export such as the demo gallery
  • Meta data export to XMP sidecar files
  • Stream photos and videos to Chromcast enabled TV devices
  • Runs on SoC such Raspberry PI

Limits

The complete "database" is loaded into the browser. My 100.000 media are about 100 MB plain JSON and 12 MB compressed JSON. The performance is quite good on current mobile device. A user reported a successful setup with over 400.000 media files. Further feedback is welcome.

Binary Downloads

HomeGallery has prebuilt binaries for Linux, MacOS and Windows. Further download options can be found here.

See installation section for usage.

External Services and Privacy

The goal of HomeGallery is to use as less public services as possible due sensitive private image data. It tries to use service which can be deployed local. However the setup requires technical knowledge and technical maintenance. Following services are called:

For geo reverse lookups (geo coordinates to address), HomeGallery queries the Nominatim Service from OpenStreetMap. Only geo coordinates are transmitted.

For reverse image lookups (similar image search), object detection and face recognition, HomeGallery uses the its own public API at api.home-gallery.org. This public API supports low powered devices such as the SoC Raspberry PI and all preview images are send to this public API by default. No images or privacy data are kept.

The API can be configured and ran also locally or as Docker container. See installation section for usage.

Customized Environments

HomeGallery runs on the JavaScript runtime NodeJS which is supported by various platforms such as Linux (also Raspberry PIs), Mac and Windows.

For most cases a customized environment should be sufficient with

  • node version 20 LTS (or 18 old LTS)
  • perl (Linux)

Setup

# Clone or download the repo from GitHub
git clone https://github.com/xemle/home-gallery.git
cd home-gallery
# Install required packages
npm install
# Build required modules
npm run build

In some corner cases you might also need essential build tools to compile library bindings.

  • make
  • g++
  • python

Development recipes

Build

HomeGallery uses npm workspaces with multi packages. Common npm scripts are clean, build, test.

To run only a subset of packages you can use pnpm's filter feature, e.g build only module export-static and database:

npx pnpm -r --filter './*/{export-static,database}' build

Unit Test

Run unit tests from specific packages (via pnpm)

npx pnpm -r --filter './*/{query,events}' test

End-To-End Test

Run specific e2e tests (via Gauge)

git clone https://github.com/xemle/home-gallery-e2e-data.git data
npm run test:e2e -- --tags dev

home-gallery-e2e-data contains test files using Git LFS.

The e2e test output data are stored in /tmp/gallery-e2e directory. The latest test run is symlinked into the directory latest-e2e-test within the HomeGallery working directory. Check the cli.log and e2e.log (ndjson format) in each test directory.

Bundle

Create local binary bundle from a feature branch

node scripts/bundle.js --version=1.3 --snapshot=-feature-test --filter=linux-x64 --no-before --no-run

Create local native bundle which excludes binaries via npm like sharp, ffmpeg and ffprobe. It should contain only js code which should run everywhere. It requires external binaries vipsthumbnail, ffmpeg and ffprobe in the PATH environment to work properly.

node scripts/bundle.js --version=1.3 --snapshot=-feature-test --filter=linux-native --no-before --no-run

Development Reset

To reset the current development state and start fresh on any very strange error behavior, you might run:

rm -rf package-lock.json node_modules e2e/node_modules packages/*/node_modules
npm install && npm run clean && npm run build

Frequently asked questions

Is home-gallery free to use?

home-gallery is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does home-gallery do?

Self-hosted open-source web gallery to view your photos and videos featuring mobile-friendly, tagging and AI powered image discovery

What is home-gallery written in?

home-gallery is primarily written in JavaScript. Its source is publicly available at https://github.com/xemle/home-gallery, and it has 1,183 GitHub stars.