Shutter

A fast and lightweight self-hosted photo catalog and manager for photographers. It consists of a Linux desktop client that uploads photos straight from your cameras to your NAS, and of a server to store and organizes these photos with their metadata. It makes browsing large RAW libraries feel instant as if the files were local, even over slow connections.

Actual state: Early prototype 🚧

The basic upload/fetch loop is working but everything is still under development and you may face important bugs or unexpected behaviors.

See AGENTS.md and docs/state for the detailed state at each step of the project.

Disclaimer

AI agents will be used regularly during the creation process of this application and all used models will appear at the end of each commit that involved one. However the developper should be responsible for any code he (or the agent under his supervision) pushes on this repository.

This project would probably not exist without the help of these LLMs as I didn't have enough time or the ambition to write this project from scratch on my free time. That's also a way for me to evaluate the current state of LLM-assisted development, something I wanted to do for a moment.

Why

Most existing tools ignore the realities of RAW-heavy libraries and imperfect networks, which makes you choose between browsing your photos comfortably and saving your disk space for your other important projects. This app is built around one specific workflow: browse, rate, and organize thousands of photos without ever feeling like you're waiting on the network.

Features

• Fast browsing: grid and full-photo views feel instant regardless of library size, powered by server-side preview generation and a bounded local cache
• Self-hosted: You're in control of your photos, all of them are stored on your own NAS/Server with XMP sidecars for metadata so you can easily switch tools at any moment
• Star ratings: fast, keyboard-driven rating (0–5)
• Tagging: free-form tags with autocomplete
• Trash: deleting flags a photo for removal with a retention window before it's permanently gone
• Open in external app: send the full-resolution original to any external editor like Darktable or Rawtherapee in one click. Edits are picked up and synced back automatically
• Import from camera / SD card: detects connected devices, skips files already in the library and either uploads them directly on the server or stages temporarly on the disk them for when you'll want to upload them
• Search & filtering: full-text search across filenames, tags, and camera metadata, plus faceted filters (lens, focal length, ISO, date range...)
• Albums & libraries: group photos into albums within a library, and keep fully independent libraries side by side on the same server: libraries don't share anything with each other, perfect to isolate your work and friend photos for example
• Simple, secure setup: no passwords, no obscure secrets configuration. Devices are authorized via a short pairing code shown in the app on first launch
• JPEG and RAW support: wide camera format coverage via LibRaw
• XMP sidecars: ratings and tags are written to standard XMP sidecars, an industry standard supported by almost every photography software out there, so the library stays portable and usable from other RAW tools
• Small footprint: target under 80MB installed, Linux-first

Usage

Server

The server is a plain cargo binary (no Qt dependencies):

cargo build -p shutter-server
./target/debug/shutter-server --addr 127.0.0.1:8080 --data-dir ~/.local/share/shutter

It generates a self-signed TLS certificate on first start and listens for HTTP/3 (QUIC) connections. There is no web UI by design — the client app is the only interface.

Client

The client needs Qt6/Kirigami and is built through CMake (which wraps cargo):

cmake -B build --install-prefix ~/.local
cmake --build build/

And install it with

cmake --install build/

Or use the executable produced by cmake inside the build/ directory.

How It Works

The app has two pieces:

• Server: runs on the machine holding your photo library. Handles ingestion, RAW preview extraction, thumbnail generation, and the photo catalog (SQLite)
• Client: a native Qt6 desktop app for Linux, built with Kirigami. Talks to the server over the network and never touches a full RAW file unless you explicitly open or export one

When you import photos, they're first copied into a local temporary staging queue on your device (nothing is sent anywhere yet). Uploading is an explicit action you trigger yourself, the app never uploads in the background without you asking it to. Once you start an upload, the server writes each file, immediately extracts the JPEG preview already embedded inside most RAW files by the camera itself, so the photo becomes browsable in the grid almost instantly. Full-quality thumbnails are generated afterward as a background job, this is the magic that makes this app so fast.

Browsing only ever requests what the current view needs, small thumbnails for the grid, a larger preview for the single-photo view, with a locally cached copy of recently viewed photos so re-browsing is instant even without a network round trip.

Tech Stack

Layer	Choice
Client UI	Qt6 / QML + Kirigami
Client/server core logic	Rust
Web framework	Axum
Database	SQLite (WAL mode)
RAW / EXIF	LibRaw (FFI), kamadak-exif / exiftool
Transport	QUIC (HTTP/3) primary, HTTP/2 + TCP fallback (planned)
Packaging	AppImage/static binary for client, docker/podman image for server

See AGENTS.md for detailed architecture decisions, open questions, phase-by-phase implementation notes, and current progress.

Roadmap

1. Core application: photo grid, upload, deletion, resumable uploads, open-with, ratings/tags/albums, RAW support, camera import with local staging and finally XMP sidecars
2. Video support
3. Search & filtering
4. Packaging & distribution (Flatpak/AppImage)
5. Network resilience — HTTP/2 + TCP fallback transport
6. Multiple libraries (full UI for creating/switching between independent libraries)
7. Near-duplicate / burst detection

License

TBD