On this page (11)
  1. What changed in v3.3.0, v3.3.1, v3.3.3, v3.3.4 and v3.3.5
  2. Verified compose file
  3. Install steps
  4. Measured resources
  5. Can Immich run on 4 GB?
  6. Can Immich run on 2 GB?
  7. Why Immich RAM usage is high, and how to reduce it
  8. Our numbers against the official requirements
  9. What we did not measure
  10. Gotchas, upgrade and backup
  11. Related

Plan on 8 GB of RAM for Immich with machine learning on, and 4 GB with it off. That is our sizing rule (the highest reading times 1.5, rounded up) applied to measurements on v3.3.5: the full four-container stack idled at 1.3 GiB once its memory had settled, used up to 2.1 GiB during its first two minutes, and peaked at 3.6 GiB processing 20 uploaded photos (medians of three runs on Oct 28, range 3.5 to 3.7 GiB for the peak). With machine learning off it idled at 1.1 GiB and peaked at 1.6 GiB under load (2.1 GiB at start-up). Immich’s docs say 6 GB minimum, 8 GB recommended. We also set container memory limits on an 8 GB host. That is not a real 2 GB or 4 GB machine. Under 4 GiB of limits the full stack finished the test and no container was killed in three runs; the machine-learning container peaked 94 MiB under its limit in the highest run and 171 MiB under in the median run, a wider margin than on v3.3.3 (27 and 30 MiB) and v3.3.1 (2 and 5 MiB) but still one test of 20 photos, not a safe setting. On our earlier sandbox host, with v3.2.4, the same limits killed its worker in all eight runs. Without machine learning, 2 GiB of limits worked in 3 of 3 runs (6 of 11 on the earlier host). v3.3.5 is a security release, so update if you run an older tag. Setup steps are on the Immich Docker Compose page.

Measured readings

Test box: Immich v3.3.5

Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.

Idle RAM
1.3 GiBsame when rounded in all 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
Startup peak RAM
2.1 GiBrange 2.0–2.1 · 3 runs highest total between healthy and settled
Peak RAM
3.6 GiBrange 3.5–3.7 · 3 runs under load, median of the run peaks
Settled after
174 srange 168–205 · 3 runs after the first healthy response
Idle CPU
3.5 %range 0.8–7.0 · 3 runs of one core, lab host
Startup
8.6 srange 8.5–9.5 · 3 runs to first healthy response
App version
v3.3.5
Tested
, 3 runs (compose file verified the same day)
How the figures are made
Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
Lab host
AMD EPYC 9V45 96-Core Processor, 2 cores, 7.7 GiB RAM, x86_64.Ubuntu 24.04.5 LTS, Docker 28.0.4.
Disk for the images
About 4.9 GB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (our estimate: unpacked plus compressed size, plus 10%; not measured on a containerd host). About 3.3 GB with the older overlay2 store (the unpacked column, as measured on this lab host). Plan for the larger figure. How we size disk
How idle was measured
After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
Peak RAM measured
Under load. Upload 20 generated 4000x3000 JPEGs (about 1 MB each, synthetic gradients and shapes, no people) through the API as the admin user, then wait until every Immich background queue (thumbnails, metadata, CLIP smart search, face detection, ...) is empty. The machine-learning container really runs; the images contain no faces, so face recognition has nothing to find. Peak and mean are taken from the first upload until the queues are idle.
Per-container figures for Immich: median over 3 runs, with the range
ContainerIdle RAMPeak RAM (under load)Image, compressed (download)Image, unpacked (disk, overlay2 store)
database380 MiBrange 368–387 · 3 runs388 MiBrange 375–394 · 3 runs205 MB756 MB
immich-machine-learning204 MiBrange 202–212 · 3 runs2.0 GiBrange 1.9–2.0 · 3 runs268 MB738 MB
immich-server730 MiBrange 727–732 · 3 runs1.2 GiBrange 1.2–1.3 · 3 runs609 MB1.7 GB
redis6 MiBrange 5–6 · 3 runs8 MiBrange 7–9 · 3 runs48 MB123 MB
Total1.3 GiBsame when rounded in all 3 runs3.6 GiBrange 3.5–3.7 · 3 runs1.1 GB3.3 GB
Every run (3)
Total RAM, startup and CPU model of each run of Immich
RunIdle RAMPeak RAMStartup peakStartupLab host CPU
11.3 GiB3.5 GiB2.1 GiB9.5 sAMD EPYC 9V45 96-Core Processor
21.3 GiB3.7 GiB2.0 GiB8.6 sAMD EPYC 9V45 96-Core Processor
3 (closest to median idle)1.3 GiB3.6 GiB2.1 GiB8.5 sAMD EPYC 9V45 96-Core Processor
Total RAM after the stack became healthy (10 s averages, run 3 of 3)
Total RAM across all containers in 10 s averages, from the moment the stack was healthy until the end of the idle window (200 s). Run 3 of 3, the one closest to the median idle. Highest 10 s average 2.0 GiB at 90 s, last 1.3 GiB at 200 s. Dashed line: the stack counted as settled at 168 s.

0 s to 200 s after healthy; the line spans 0 to 2.0 GiB. Dashed line: settled.

Timeline as a table
Total RAM, 10 s average ending at each time, every 30 s after healthy
Seconds after healthyTotal RAM
302.0 GiB
602.0 GiB
902.0 GiB
1201.3 GiB
1501.3 GiB
1801.3 GiB
2001.3 GiB

RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.

Lab notes (4)
  • Warning: immich-server restarted 1 time(s) during the run (run 1 of 3)
  • The .env adds IMMICH_HOST=0.0.0.0: the lab host has no IPv6, and the ML container binds [::] by default and crash-loops without it.
  • Compose follows the Immich release file with named volumes instead of bind mounts (see the comments in the compose file).
  • Hardware acceleration (GPU/iGPU) is not tested: the lab host has none.

What changed in v3.3.0, v3.3.1, v3.3.3, v3.3.4 and v3.3.5

We re-tested on v3.3.0, a minor release, on Oct 8, after v3.2.4, on v3.3.1, a patch release, on Oct 15, on v3.3.3, another patch release, on Oct 21, and on v3.3.5, a patch release with security fixes, on Oct 28. This page’s numbers are the Oct 28 runs. The host changed in the step to v3.3.0 (see Measured resources), so a difference between those numbers and the v3.2.4 ones is not necessarily the version. What we read in the release notes and docs, with the sources marked (lab/notes/immich-2026-10-08.md for v3.3.0, lab/notes/release-check-2026-10-15.md for v3.3.1, lab/notes/patch-batch-2026-10-21.md for v3.3.3, lab/notes/patch-batch-2026-10-28.md for v3.3.4 and v3.3.5):

  • No breaking changes listed. The release page has no breaking-changes or migration section (read through a web-fetch tool on Oct 8, 2026, which returns a summary, so treat that as unverified). The upgrading page at v3.3.0 says “We intend for breaking changes, including those to the API or deployment, to be limited to major version releases.” (read from the file itself).
  • Machine learning, opt-in. The release notes, as the web-fetch tool summarized them, describe a new model revision that is “faster and uses less memory across backends”, switched on with MACHINE_LEARNING_MODEL_REVISION=v2 on the machine-learning container and meant to become the default in a later release (unverified wording). We did not set it, so our numbers are for the default settings. Other machine-learning items in the notes (model loading, inference, PP-OCRv6 OCR models, GPU back ends) were not measured here; the lab host has no GPU.
  • Thumbnail and job changes. “Linear-light resampling” for thumbnails and previews, and a fix that stops queueing unneeded jobs when there is no XMP file (both from the same web-fetch summary, unverified). Neither is described as a memory change. Our upload test showed the load peak move from 3,454 MiB (v3.2.4) to 3,546 MiB (v3.3.0) with the host also changed, so we cannot say whether the version moved it.
  • A new default. MACHINE_LEARNING_MAX_BATCH_SIZE__FACIAL_RECOGNITION now defaults to 4 (it was unset, or 1 with OpenVINO), per the environment variable docs at v3.3.0, read from the file. Our generated images contain no faces and we set neither value, so this test does not exercise it.
  • Compose file. Against the upstream v3.3.0 compose file, the only change to our files was the Valkey image digest (Valkey 9.1.1 became 9.1.2 in our runs). The Immich image tags and the database image are as before.
  • v3.3.1. The release page, read through a web-fetch tool on Oct 15, 2026 (a summary, so unverified), has no breaking-change or upgrade section and no item about memory, performance, Docker or migration. Its one machine-learning item is a docs entry for MACHINE_LEARNING_MODEL_REVISION. The upstream compose file and example.env at v3.3.1, which we read with curl, needed no edit to ours beyond the two Immich tags: the Valkey and database digests are the same as at v3.3.0. Between our v3.3.0 and v3.3.1 full-stack runs the median idle moved from 1,380 to 1,424 MiB and the median load peak from 3,546 to 3,349 MiB, with overlapping ranges (idle 1,378 to 1,400 and 1,354 to 1,450; peak 3,395 to 3,667 and 3,348 to 3,635), on the same CPU model. We do not credit the difference to the version.
  • v3.3.3. The release page (released Oct 14, 2026), read through a web-fetch tool on Oct 21, 2026 (a summary, so unverified), lists two bug fixes: a mobile fix for the memories date and “perf(server): improve people query performance” (#32405). It has no breaking-change, security or migration section. The release page for v3.3.2 returned 404, and we did not test a v3.3.2. The upstream compose file and example.env at v3.3.3, which we read with curl on Oct 21, needed no edit to ours beyond the two Immich tags: the Valkey and database digests are the same as at v3.3.1 and depends_on is still the plain list. Between our v3.3.1 and v3.3.3 full-stack runs the median idle moved from 1,424 to 1,324 MiB and the median load peak from 3,349 to 3,685 MiB. The idle ranges do not overlap (1,354 to 1,450 and 1,296 to 1,338); the peak ranges do (3,348 to 3,635 and 3,352 to 3,726). The CPU model changed in the same step (AMD EPYC 9V74 to Intel Xeon 6973P-C) and so did the runner image (kernel 6.17 to 7.0), so we do not credit either difference to the version. The people-query change is not described as a memory change, and we would not expect it to show in our test, whose images contain no faces; we did not check.
  • v3.3.4. The release page (released Oct 20, 2026; read through a web-fetch tool on Oct 21 and Oct 28, so unverified) lists a missing-translation fix and another change to how the server queries people (“perf(server): more efficient person queries”, #32523), and no breaking-change, security or migration section. We did not run v3.3.4 on its own: our Oct 28 runs are v3.3.5, which comes after it.
  • v3.3.5, a security release. The release page (released Oct 21, 2026; read through a web-fetch tool on Oct 28 and again on Oct 29, so the wording is a tool’s rendering and unverified) has a Security section with two dependency updates, “update python docker digests” (#32635) and “update dependency certifi to v2026.10.19” (#32636). Its intro says the release contains “a fix for today’s CA compromise” and “some nodejs security patches”, and recommends that you “update as soon as possible”, while saying the authors do not believe the compromise brings an immediate danger to Immich instances. We read no breaking-change, migration or new-variable item, and we did not test what the security fixes change. The upstream docker-compose.yml of v3.3.5, read through the same tool on Oct 29, needed no edit to ours beyond the two Immich tags: it has the same Valkey and database digests as ours and depends_on is still the plain list. Between our v3.3.3 and v3.3.5 full-stack runs the median idle moved from 1,324 to 1,321 MiB and the median load peak from 3,685 to 3,701 MiB, with overlapping ranges (idle 1,296 to 1,338 and 1,308 to 1,330; peak 3,352 to 3,726 and 3,538 to 3,802). The CPU model changed in the same step (Intel Xeon 6973P-C to AMD EPYC 9V45) and so did the runner image (20261018 to 20261026, kernel 7.0 both times), so we do not credit either difference to the version. None of the security items is described as a memory change.

Verified compose file

The stack is the same as in the verified compose file and setup guide, so that file is not repeated here. The RAM variants we ran are small edits of it. This is the file for the stack without machine learning: the immich-machine-learning service and the model-cache volume are removed. The 4 GiB and 2 GiB runs add one mem_limit line to each service (the split is in the file header); download them from the table under Measured resources or from the Test boxes.

compose.yamlVerified 2026-10-28 · Immich (no machine learning) v3.3.5Download compose.yaml for Immich (no machine learning)
# Verified compose for Immich (no machine learning), tested 2026-10-28 by the SelfHostBench lab (3 runs; the figures are the median).
# Lab host: AMD EPYC 7763 64-Core Processor, 2 vCPU, 7.8 GiB RAM, x86_64, Docker 28.0.4.
# Floating image tags below were replaced by the version resolved at test time;
# the registry digest is in the comment on each image line.
# Measurements: immich-no-ml.json (schema 3).
# Companion env file: immich-no-ml.env (save it as .env next to this file).
# Secrets are not published: the lab's values are public. In immich-no-ml.env:
#   DB_PASSWORD=CHANGE_ME_DB_PASSWORD. Replace it with your own before the first start.

# Immich: self-hosted photo and video library (this variant: machine learning disabled).
#
# Based on the compose file of the current Immich release:
#   https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
# Changes from the release file (everything else is as shipped):
#   * the upload and database folders are named volumes instead of the ./library and
#     ./postgres bind mounts, so the stack can run on a remote Docker host and `down -v`
#     leaves nothing behind. Use bind mounts (UPLOAD_LOCATION / DB_DATA_LOCATION in .env)
#     if you want photos in a folder you can see.
#   * the extends/hardware-acceleration comments are removed (not tested here).
# Put DB_PASSWORD and friends in the .env file next to this file.
#
# VARIANT (SelfHostBench lab): same stack, WITHOUT machine learning.
# Done the way Immich's FAQ describes (https://docs.immich.app/FAQ#how-can-i-disable-machine-learning):
#   1. Machine learning is switched off under Administration > Settings > Machine Learning
#      (the lab does this through the API in disable_ml.py), and
#   2. the `immich-machine-learning` section is removed from the compose file, so the container never starts.
# The model-cache volume is removed with it. No memory limits.

name: immich

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:v3.3.5  # sha256:485d546a2e31d6a8b4db8423fcba5c109de8c218d93410af115fd1ccfc4352a6  (version v3.3.5, from label:org.opencontainers.image.version)
    volumes:
      # Originals, thumbnails, encoded video. This is your photo library: back it up.
      - immich-upload:/data
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - .env
    ports:
      - '2283:2283'
    depends_on:
      - redis
      - database
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:9@sha256:c123e3715db63d06d4ad6964884037aa0d5d4d703939b9929954112889708e1d  # version 9.1.2 (from exec); no registry tag for it could be verified, so the digest is pinned instead
    healthcheck:
      test: redis-cli ping | grep -q PONG || exit 1
    restart: always

  database:
    container_name: immich_postgres
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0  # sha256:bcf63357191b76a916ae5eb93464d65c07511da41e3bf7a8416db519b40b1c23  (version 14-vectorchord0.4.3-pgvector0.8.1-pgvectors0.2.0, from label:org.opencontainers.image.version)
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
      POSTGRES_INITDB_ARGS: '--data-checksums'
      # Uncomment the DB_STORAGE_TYPE: 'HDD' var if your database isn't stored on SSDs
      # DB_STORAGE_TYPE: 'HDD'
    volumes:
      # The Immich database (albums, users, search index). Back this up with pg_dump.
      - immich-db:/var/lib/postgresql/data
    shm_size: 128mb
    restart: always
    healthcheck:
      disable: false

volumes:
  immich-upload:
  immich-db:

Install steps

Start from the setup in the Immich Docker Compose guide, but use the file above with its .env, and start it. The downloadable .env has the placeholder CHANGE_ME_DB_PASSWORD for DB_PASSWORD; replace it first, as in step 4 of that guide. The lab ran with its own database password; the numbers do not depend on it.

bash
docker compose up -d

Machine learning also has to be switched off in Immich’s settings. Immich’s FAQ says to do that under Administration > Settings > Machine Learning Settings, and that disabling every job does not stop the service itself, so you also remove the immich-machine-learning section from the compose file. Not run in our lab: the settings screen. The lab made the same change through the admin settings API (disable_ml.py, which prints machineLearning.enabled after: False).

To check memory and kills on a running stack we used these commands, on the earlier sandbox host between Oct 1 and Oct 6. The first prints each container’s memory use, the second its restart count and whether the kernel killed it for memory.

bash
docker stats --no-stream --format '{{.Name}}={{.MemUsage}}' immich_machine_learning immich_server
docker inspect -f 'RestartCount={{.RestartCount}} OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}} MemLimit={{.HostConfig.Memory}} Status={{.State.Status}}' immich_machine_learning
docker logs immich_machine_learning

Measured resources

All numbers come from lab results on one machine type: a GitHub Actions ubuntu-latest runner (2 vCPU, 8 GB; 7.7 to 7.8 GiB RAM, Docker 28.0.4), Immich v3.3.5, three runs of each variant on Oct 28, 2026, each from a fresh stack. The CPU model was AMD EPYC 9V45 for the full stack and the concurrency-1 variant, EPYC 7763 for the no-ML and 4 GiB variants and Intel Xeon Platinum 8370C for the 2 GiB variant: same machine type, different physical CPUs (and, for the last, a different vendor), and all three runs of a variant landed on one model. Two runner images were in use: the full stack and the 2 GiB variant ran on the kernel 7.0.0 image (20261026.354.1), the other three on the kernel 6.17.0 image (20261023.334.3). Every figure is the median of the three runs, with the range (lowest to highest run) in brackets (why we repeat runs). In each run idle is the mean of 11 samples over 30 s, taken after the stack’s total memory had settled (165 to 265 s after the stack was healthy, depending on the run; the rule is on the methodology page). Startup peak is the highest total between healthy and settled. Peak is the highest simultaneous total while the load ran. The load was the same every time: 20 generated 4000x3000 JPEGs (23.1 MB) uploaded through the API, then a wait until every job queue was empty. The images have no faces, and there is no video. Memory is the working set docker stats reports. The upload took 0.8 to 1.7 s in every run. No variant was flagged as varying (the flag needs the highest run to be more than 1.5 times the lowest); the 2 GiB variant came closest (ratio 1.28, see below the table). The earlier results of this page (v3.2.4 on the sandbox host with 4 vCPU and 15.7 GiB, Oct 6; v3.3.0, Oct 8; v3.3.1, Oct 15; and v3.3.3, Oct 21, on the runner) are no longer in the table; the old and new figures are side by side in the update log, the earlier repeats are in the lab notes, and the earlier result files are in the repository history.

| Run, version, test date, files | Idle RAM, settled (MiB) | Startup peak (MiB) | Peak RAM under load (MiB) | Time until all queues idle (s) | Settled after healthy (s) | Memory limits | |—|—|—|—|—| | Full stack
Immich v3.3.5, tested 2026‑10‑28
Result JSON, compose.yaml, .env | 1,321 (1,308 to 1,330) | 2,145 (2,083 to 2,167) | 3,701 (3,538 to 3,802) | 51.7 (51.7 to 54.3) | 174 (168 to 205) | none | | Full stack, ML job concurrency 1
Immich v3.3.5, tested 2026‑10‑28
Result JSON, compose.yaml, .env | 1,407 (1,335 to 1,419) | 2,248 (2,173 to 2,324) | 3,685 (3,613 to 3,811) | 48.8 (45.4 to 49.2) | 176 (176 to 265) | none | | No machine learning
Immich v3.3.5, tested 2026‑10‑28
Result JSON, compose.yaml, .env | 1,090 (1,075 to 1,132) | 2,080 (1,712 to 2,117) | 1,670 (1,633 to 1,701) | 21.2 (21.0 to 21.3) | 178 (176 to 180) | none | | Full stack, 4 GiB of caps
Immich v3.3.5, tested 2026‑10‑28
Result JSON, compose.yaml, .env | 1,406 (1,342 to 1,411) | 1,923 (1,912 to 2,036) | 3,073 (2,917 to 3,298) | 60.6 (60.5 to 64.1) | 190 (176 to 200) | 4,096 MiB in total | | No machine learning, 2 GiB of caps
Immich v3.3.5, tested 2026‑10‑28
Result JSON, compose.yaml, .env | 1,063 (1,037 to 1,324) | 1,738 (1,607 to 1,747) | 1,536 (1,501 to 1,644) | 24.3 (24.1 to 24.3) | 185 (165 to 192) | 2,048 MiB in total |

The “Settled after healthy” column is when the stack’s total memory counted as settled, the point where the idle measurement started. Each result file holds the three runs in full. No container had OOMKilled set at the end of any run in any row. immich-server restarted once (restart count 1) in 2 of the 15 runs: in run 1 of the full-stack row and in run 1 of the concurrency-1 row. The no-ML, 4 GiB and 2 GiB rows had no restart. The harness saved the log at each of the two; the cause is below.

The 2 GiB row’s idle range is wide because of one run. Idle was 1,037, 1,324 and 1,063 MiB in runs 1 to 3. In run 2 the server held 959 MiB across the idle window where it held 675 and 694 MiB in runs 1 and 3 (Postgres and Valkey were the same in all three). The memory timeline shows why: in run 2 the server stepped down from about 1,070 MiB to 960 MiB at 120 s after healthy and stayed there to the end of the timeline at 200 s, while in run 3 it fell from 947 to 698 MiB at 140 s. The settle rule (total memory flat to within max(2%, 10 MiB) over 60 s) counted the stack as settled at 162 s on that plateau. We do not know why the second step did not come in that run, or whether it would have come later. The median (1,063 MiB) is not affected, and the highest/lowest ratio of 1.28 is below the 1.5 that sets the variance flag, so the result is not flagged.

Why immich-server sometimes restarts once at start-up, with or without machine learning. In the Oct 28 runs (v3.3.5) the harness captured the container’s log when it first saw each restart (immich.restarts.log and immich-ml-1job.restarts.log in lab/results/; the lines we quote are copied into the lab note patch-batch-2026-10-28.md). Both logs show the same thing as before: the first immich-server start logged Error: connect ECONNREFUSED <database address>:5432 1.7 and 1.8 s after it began, because Postgres was not yet accepting connections, and Docker’s restart: always started the container again 0.4 and 0.5 s later. The second start ran normally to the end of the run. OOMKilled was False in both captures, and the end-of-run capture of each run still showed a restart count of 1, so each of those runs had exactly one restart and none was a memory kill. The five restarts of the Oct 21 runs on v3.3.3 (patch-batch-2026-10-21.md), the six of the Oct 15 runs on v3.3.1 (lab/notes/immich-2026-10-15.md) and a diagnostic run on Oct 10 on v3.3.0 (immich-2026-10-10.md) logged the same error. That makes fourteen logged restarts across five stacks and four versions, all the same refused connection. The no-ML result of Oct 28 has no restart log because none of its runs restarted.

How often it happened differed by stack, and the stacks that restarted in every run were not the same from batch to batch:

| Stack | Oct 8, v3.3.0 (no logs saved) | Oct 15, v3.3.1 | Oct 21, v3.3.3 | Oct 28, v3.3.5 | |—|—|—|—| | Full stack | 0 of 3 runs | 1 of 3 | 1 of 3 | 1 of 3 | | Full stack, ML job concurrency 1 | 0 of 3 | 1 of 3 | 1 of 3 | 1 of 3 | | No machine learning | 3 of 3 | 0 of 3 | 3 of 3 | 0 of 3 | | Full stack, 4 GiB of caps | 0 of 3 | 1 of 3 | 0 of 3 | 0 of 3 | | No machine learning, 2 GiB of caps | 3 of 3 | 3 of 3 | 0 of 3 | 0 of 3 |

That is 6, 6, 5 and 2 of 15 runs. The uncapped no-ML stack restarted in every run on two of the four dates and in none on the other two, and the 2 GiB stack in every run on two dates and in none on the other two. So the restart is not specific to the no-ML stack or to the caps, and nothing in these 60 runs tells us which stack will restart next. One pattern does show in the three stacks with machine learning on (full, concurrency 1 and 4 GiB): all seven of their restarts were in run 1 of the three, and none in the 24 runs numbered 2 or 3. The stacks without machine learning restarted in all three runs or in none. The same stack restarted in some runs and not in others, so we infer that it depends on timing, on whether the server’s first connection attempt comes before Postgres is ready. We cannot say whether machine learning or the caps change the odds. The Oct 8 counts are the restart_count values in the result files of that date (commit d029d60 in the repository history); the harness saved no logs then, so we do not know the cause of those six and only note that it fits the same pattern.

The logs show the symptom; the start-order race is our reading of the compose file. Immich’s compose file, and ours, has depends_on: [redis, database] with no condition, so Compose starts the server once the database container has started, not once Postgres is ready.

The database service has a health check: healthcheck: disable: false keeps the one built into the Immich Postgres image (a check every 5 s during a 5-minute start period; read from the image config, see the lab note, and the base-images Dockerfile). The 5 s start interval needs Docker Engine 25.0 or later; on older engines the first check runs 5 minutes after start (Dockerfile reference). Docker’s startup-order page says “Compose waits for healthchecks to pass on dependencies marked with service_healthy”, so waiting for the database should avoid the restart. The official file still uses the plain list (v3.3.3 read with curl on Oct 21, 2026; v3.3.5 read through a web-fetch tool on Oct 29). Not tested in our lab.

Not run in our lab. Replace the depends_on list under immich-server with:

yaml
    depends_on:
      redis:
        condition: service_started
      database:
        condition: service_healthy

Per container, full stack

Container Idle RAM, settled (MiB) Startup peak (MiB) Peak RAM under load (MiB)
immich-server 730 (727 to 732) 1,442 (1,425 to 1,505) 1,258 (1,253 to 1,350)
immich-machine-learning 204 (202 to 212) 265 (262 to 272) 2,055 (1,910 to 2,075)
database (Postgres) 380 (368 to 387) 552 (535 to 604) 388 (375 to 394)
redis (Valkey) 6 (5 to 6) 6 (5 to 6) 8 (7 to 9)
Stack 1,321 (1,308 to 1,330) 2,145 (2,083 to 2,167) 3,701 (3,538 to 3,802)

The machine-learning container is the swing: 204 MiB idle and 2,055 MiB at its peak (median; 1,910 to 2,075). It idled at 163 MiB on the earlier host with v3.2.4, and its start-up peak was 265 MiB (262 to 272) against 162; we do not know whether the version or the host did that. The peaks of the four containers do not happen at the same instant, which is why the stack’s peak is lower than the sum of the four (in the median run, 3,701 MiB against 3,710 MiB). Source: immich.json.

Without machine learning

Switching machine learning off cut the median load peak from 3,701 MiB to 1,670 MiB, and the job queues emptied in 21.2 s instead of 51.7 s, with the machine-learning jobs disabled. The server (680 MiB idle, 1,231 MiB at its load peak, 1,436 MiB at start-up), Postgres (385 MiB idle, 392 MiB at its load peak, 632 MiB at start-up) and Valkey (10 MiB) stayed (medians of three runs; ranges are in immich-no-ml.json). The stack’s start-up peak (2,080 MiB, in the first two minutes) was higher than its load peak (1,670 MiB) in all three runs. By our rule, which takes the higher of the two peaks in the highest run, that is 2,117 MiB times 1.5, which is 3.1 GiB and rounds up to 4 GB (immich-no-ml.json). The two stacks ran on different CPU models (AMD EPYC 9V45 and EPYC 7763), so the job times are not a like-for-like comparison.

Measured readings

Test box: Immich (no machine learning) v3.3.5

Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.

Idle RAM
1.1 GiBrange 1.0–1.1 · 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
Startup peak RAM
2.0 GiBrange 1.7–2.1 · 3 runs highest total between healthy and settled
Peak RAM
1.6 GiBrange 1.6–1.7 · 3 runs under load, median of the run peaks
Settled after
178 srange 176–180 · 3 runs after the first healthy response
Idle CPU
1.4 %range 0.5–4.1 · 3 runs of one core, lab host
Startup
10 srange 10–11 · 3 runs to first healthy response
App version
v3.3.5
Tested
, 3 runs (compose file verified the same day)
How the figures are made
Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
Lab host
AMD EPYC 7763 64-Core Processor, 2 cores, 7.8 GiB RAM, x86_64.Ubuntu 24.04.5 LTS, Docker 28.0.4.
Disk for the images
About 3.8 GB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (our estimate: unpacked plus compressed size, plus 10%; not measured on a containerd host). About 2.6 GB with the older overlay2 store (the unpacked column, as measured on this lab host). Plan for the larger figure. How we size disk
How idle was measured
After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
Peak RAM measured
Under load. Upload 20 generated 4000x3000 JPEGs (about 1 MB each, synthetic gradients and shapes, no people) through the API as the admin user, then wait until every Immich background queue (thumbnails, metadata, CLIP smart search, face detection, ...) is empty. Machine learning is disabled and its container is not running, so smart search and face detection do no work. Peak and mean are taken from the first upload until the queues are idle.
Per-container figures for Immich (no machine learning): median over 3 runs, with the range
ContainerIdle RAMPeak RAM (under load)Image, compressed (download)Image, unpacked (disk, overlay2 store)
database385 MiBrange 379–442 · 3 runs392 MiBrange 386–449 · 3 runs205 MB756 MB
immich-server680 MiBrange 680–699 · 3 runs1.2 GiBrange 1.2–1.3 · 3 runs609 MB1.7 GB
redis10 MiBrange 10–12 · 3 runs11 MiBrange 11–13 · 3 runs48 MB123 MB
Total1.1 GiBrange 1.0–1.1 · 3 runs1.6 GiBrange 1.6–1.7 · 3 runs862 MB2.6 GB
Every run (3)
Total RAM, startup and CPU model of each run of Immich (no machine learning)
RunIdle RAMPeak RAMStartup peakStartupLab host CPU
11.0 GiB1.6 GiB1.7 GiB11 sAMD EPYC 7763 64-Core Processor
21.1 GiB1.6 GiB2.1 GiB10 sAMD EPYC 7763 64-Core Processor
3 (closest to median idle)1.1 GiB1.7 GiB2.0 GiB10 sAMD EPYC 7763 64-Core Processor
Total RAM after the stack became healthy (10 s averages, run 3 of 3)
Total RAM across all containers in 10 s averages, from the moment the stack was healthy until the end of the idle window (210 s). Run 3 of 3, the one closest to the median idle. Highest 10 s average 1.8 GiB at 20 s, last 1.1 GiB at 210 s. Dashed line: the stack counted as settled at 178 s.

0 s to 210 s after healthy; the line spans 0 to 1.8 GiB. Dashed line: settled.

Timeline as a table
Total RAM, 10 s average ending at each time, every 30 s after healthy
Seconds after healthyTotal RAM
301.8 GiB
601.8 GiB
901.8 GiB
1201.4 GiB
1501.1 GiB
1801.1 GiB
2101.1 GiB

RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.

Lab notes (4)
  • Machine learning is disabled the way Immich's FAQ describes (https://docs.immich.app/FAQ#how-can-i-disable-machine-learning, read 2026-10-01): switched off under Administration > Settings > Machine Learning Settings (done through the API by disable_ml.py), and the immich-machine-learning section removed from compose.yaml so the container does not start.
  • The .env adds IMMICH_HOST=0.0.0.0: the lab host has no IPv6, and Immich containers listen on [::] by default (the ML container crash-loops without it).
  • Same stack, .env and upload load as apps/immich (Immich v3 release image tags, 20 generated 4000x3000 JPEGs); the setup and upload scripts are shared with that app.
  • Hardware acceleration (GPU/iGPU) is not tested: the lab host has none.

How long “idle” lasts

The server container uses about 1.3 to 1.4 GiB for roughly its first two minutes after the stack is healthy, then drops to about 0.7 GiB. We wait for that before we measure idle (rule on the methodology page). The memory timelines in the result files show it: in the median run of immich-no-ml.json the server holds about 1.4 GiB (1,406 to 1,416 MiB in each 10 s average from 20 s to 90 s after healthy), is at 1,369 MiB at 100 s, 1,052 MiB at 120 s and 703 MiB at 130 s, and stays at 692 to 703 MiB to the end of the timeline, 210 s after healthy. The other two runs show the same drop, finishing at 671 MiB (220 s) and 674 MiB (210 s). The drop is not always that clean: in run 2 of immich-no-ml-2g.json the server fell only to 960 MiB at 120 s and stayed there to the end of the timeline at 200 s, and the settle rule counted the stack as settled on that plateau (see the note under the table above), while in run 3 of the same file it fell from 947 to 698 MiB at 140 s. On the earlier sandbox host we also watched the no-ML stack by hand for 10 minutes on Oct 1, with v3.2.4, no photos uploaded and no memory limits (lab notes, immich-memory-caps-2026-10-01.md, section 6): the server fell from 1.4 to 1.5 GiB to about 730 MiB between roughly 1:40 and 2:10 after healthy, and stayed between 655 and 730 MiB to the end. Postgres sat at about 419 MiB, Valkey at 5 MiB. We did not investigate why the server’s memory falls. Until Oct 2 this page quoted idle figures taken 70 to 100 s after the stack was healthy, inside the first phase (2,162 MiB for the full stack on v3.2.4, against 1,321 now). The methodology page describes the change, and the old and new values are side by side in the lab notes (methodology-change-2026-10-02.md). We watched one hand-run and a handful of timelines, so we do not know how long the phase lasts on other hosts, or what the full stack does beyond the end of the timelines (200 to 300 s after healthy). We still size from the peaks.

Can Immich run on 4 GB?

Without machine learning, probably yes. With it, not comfortably. Everything below comes from container memory limits on an 8 GB host, not from a real 4 GB machine. Immich’s requirements page says: “For systems with only 4GB of RAM, Immich can be run with machine learning features disabled.” Our no-ML stack’s highest reading was 2.1 GiB (2,117 MiB in the highest run, at start-up); it idled at 1.1 GiB and peaked at 1.6 GiB under load. A 4 GB host is about 3.7 GiB, so that would leave roughly 1.6 GiB for the operating system at the highest reading, if a real 4 GB host behaves like our limits did. We did not test one. One more caution: on v3.3.5 immich-server restarted once in 2 of our 15 runs, in two of the five stacks (run 1 of the full stack and of the concurrency-1 stack; none of the no-ML, 4 GiB or 2 GiB runs; it was 5 of 15 on v3.3.3). In every one the log shows a refused database connection at start-up, not a memory kill (see Measured resources). Docker restarts the server within about a second, so we do not count it against the setup.

With machine learning on, we ran the full stack with a hard memory limit on every container, adding up to 4,096 MiB: server 1,536 MiB, machine learning 1,664 MiB, database 768 MiB, Valkey 128 MiB. The same upload test finished in all three runs on v3.3.5, as it did on v3.3.3 (Oct 21), v3.3.1 (Oct 15) and v3.3.0 (Oct 8): all 20 uploads were processed, a smart search returned all 20 images, no job failed (immich-4g.json, queues idle after 60.6 s in the median run), OOMKilled was false on all four containers, and every container had a restart count of 0. The machine-learning container came closest to its limit in one of the three runs. It peaked at 1,570 MiB in the highest run, against the 1,664 MiB limit, which is 94 MiB under; in the median run it peaked at 1,493 MiB (171 MiB under) and in the third run at 1,240 MiB (424 MiB under). On v3.3.3 the highest run was 27 MiB under the limit and the median 30 MiB under; on v3.3.1 the highest was 2 MiB under and the median 5 MiB under (median peak 1,659 MiB); on v3.3.0 the highest was 5 MiB under and the median 13 MiB. The memory.stat that the harness reads just after the stack’s highest sample splits the figure: in run 1, the run with the highest machine-learning peak, the container held 1,487 MiB of anonymous memory and 145 MiB of file cache at that read, so the anonymous part was 177 MiB under the limit; in runs 2 and 3 it held 1,190 and 1,222 MiB of anonymous memory and 415 and 366 MiB of file cache. That is one reading per run, taken a moment after the sample, and we did not measure how much of the cache the kernel would drop before it killed anything. A margin of 94 MiB on a 20-photo test with no faces is wider than on the last two versions but is not a safety margin either: a different photo set, model or version could cross it, and we tested none of them. The server peaked at 1,229 MiB (limit 1,536), Postgres at 457 MiB (limit 768) (medians).

That is a different result from our earlier runs. On the sandbox host (4 vCPU, 15.7 GiB) with v3.2.4, the same limits and the same upload test flagged the machine-learning container as out-of-memory killed in all eight runs: two on Oct 1, three on Oct 2 and three on Oct 6. In each, OOMKilled was true and the restart count stayed 0, so the container never stopped. On Oct 1, Docker’s event log showed an out-of-memory event during the load, and the ML log of the second run read Worker (pid:15) was sent SIGKILL! Perhaps out of memory? two seconds after it began loading the buffalo_l face model, then booted a new worker. So the kernel killed a worker process and the service replaced it. In the Oct 2 run that was committed at the time the ML container reached 1,664 MiB, exactly its limit, and a smart search for the 20 images returned only 14 of them, although no job was reported failed; the other seven runs returned all 20. Raw output for those runs is in the lab notes (immich-memory-caps-2026-10-01.md section 3 and methodology-change-2026-10-02.md section 4.2). We do not know why the Actions runs were not killed. The version, the host (2 vCPU instead of 4, a different CPU, Docker 28.0.4 instead of 29.6.2, kernel 6.17 or 7.0 instead of 6.18) and the slower machine-learning jobs (queues idle after 60.6 s here, 39 s there) all changed at once, and the twelve runs on the runner (three each on v3.3.0, v3.3.1, v3.3.3 and v3.3.5) cannot separate them. We treat the cap as a risk that remains: no kill in twelve runs is not a guarantee, and the container used 89.7% of its limit in the median run of v3.3.5 (94.3% in the highest; 98.4% in the highest run of v3.3.3 and 99.9% in the highest run of v3.3.1).

Measured readings

Test box: Immich (4 GiB cap) v3.3.5

Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.

Idle RAM
1.4 GiBrange 1.3–1.4 · 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
Startup peak RAM
1.9 GiBrange 1.9–2.0 · 3 runs highest total between healthy and settled
Peak RAM
3.0 GiBrange 2.8–3.2 · 3 runs under load, median of the run peaks
Settled after
190 srange 176–200 · 3 runs after the first healthy response
Idle CPU
2.7 %range 1.0–6.8 · 3 runs of one core, lab host
Startup
13 srange 12–15 · 3 runs to first healthy response
App version
v3.3.5
Tested
, 3 runs (compose file verified the same day)
How the figures are made
Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
Lab host
AMD EPYC 7763 64-Core Processor, 2 cores, 7.8 GiB RAM, x86_64.Ubuntu 24.04.5 LTS, Docker 28.0.4.
Disk for the images
About 4.9 GB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (our estimate: unpacked plus compressed size, plus 10%; not measured on a containerd host). About 3.3 GB with the older overlay2 store (the unpacked column, as measured on this lab host). Plan for the larger figure. How we size disk
How idle was measured
After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
Peak RAM measured
Under load. Upload 20 generated 4000x3000 JPEGs (about 1 MB each, synthetic gradients and shapes, no people) through the API as the admin user, then wait until every Immich background queue (thumbnails, metadata, CLIP smart search, face detection, ...) is empty. The machine-learning container really runs; the images contain no faces, so face recognition has nothing to find. Every container has a hard memory limit; the limits add up to 4 GiB. Peak and mean are taken from the first upload until the queues are idle.
Per-container figures for Immich (4 GiB cap): median over 3 runs, with the range
ContainerIdle RAMPeak RAM (under load)Image, compressed (download)Image, unpacked (disk, overlay2 store)
database441 MiBrange 396–442 · 3 runs457 MiBrange 412–468 · 3 runs205 MB756 MB
immich-machine-learning208 MiBrange 204–211 · 3 runs1.5 GiBrange 1.2–1.5 · 3 runs268 MB738 MB
immich-server743 MiBrange 727–752 · 3 runs1.2 GiBrange 1.2–1.3 · 3 runs609 MB1.7 GB
redis11 MiBrange 10–14 · 3 runs12 MiBrange 12–15 · 3 runs48 MB123 MB
Total1.4 GiBrange 1.3–1.4 · 3 runs3.0 GiBrange 2.8–3.2 · 3 runs1.1 GB3.3 GB
Every run (3)
Total RAM, startup and CPU model of each run of Immich (4 GiB cap)
RunIdle RAMPeak RAMStartup peakStartupLab host CPU
11.3 GiB3.2 GiB1.9 GiB15 sAMD EPYC 7763 64-Core Processor
21.4 GiB2.8 GiB1.9 GiB12 sAMD EPYC 7763 64-Core Processor
3 (closest to median idle)1.4 GiB3.0 GiB2.0 GiB13 sAMD EPYC 7763 64-Core Processor
Total RAM after the stack became healthy (10 s averages, run 3 of 3)
Total RAM across all containers in 10 s averages, from the moment the stack was healthy until the end of the idle window (210 s). Run 3 of 3, the one closest to the median idle. Highest 10 s average 1.8 GiB at 20 s, last 1.4 GiB at 210 s. Dashed line: the stack counted as settled at 176 s.

0 s to 210 s after healthy; the line spans 0 to 1.8 GiB. Dashed line: settled.

Timeline as a table
Total RAM, 10 s average ending at each time, every 30 s after healthy
Seconds after healthyTotal RAM
301.8 GiB
601.8 GiB
901.8 GiB
1201.5 GiB
1501.4 GiB
1801.4 GiB
2101.4 GiB

RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.

Lab notes (4)
  • Memory caps are compose `mem_limit` values per container (hard limits: a container over its limit is OOM-killed). Docs: https://docs.immich.app/FAQ#can-i-limit-cpu-and-ram-usage (read 2026-10-01). The split and its sum are in the header of compose.yaml. RestartCount and OOMKilled per container are in services.<name>.restart_count / oom_killed.
  • The .env adds IMMICH_HOST=0.0.0.0: the lab host has no IPv6, and Immich containers listen on [::] by default (the ML container crash-loops without it).
  • Same stack, .env and upload load as apps/immich (Immich v3 release image tags, 20 generated 4000x3000 JPEGs); the setup and upload scripts are shared with that app.
  • Hardware acceleration (GPU/iGPU) is not tested: the lab host has none.

What this does not show: a 4 GB machine. The caps add up to 4 GiB (4,096 MiB, about 4.3 GB) for the containers alone, more than a 4 GB host has in total. A real 4 GB host (about 3.7 GiB) also runs the operating system, Docker and the file cache. Our uncapped full-stack peak of 3.6 GiB (3,701 MiB in the median run, 3,802 MiB in the highest) would leave under 0.1 GiB for all of that in the median run and next to nothing in the highest (3,802 MiB against the roughly 3,800 MiB that 4 GB amounts to), and the ML container came within 94 MiB of its 1,664 MiB limit in one of three runs. We would not run the full stack on 4 GB. We would turn machine learning off, as the docs say. Photos with faces and a library larger than 20 images are not in this test.

Can Immich run on 2 GB?

Without machine learning, in containers capped at 2,048 MiB in total, it worked on v3.3.5, v3.3.3, v3.3.1 and v3.3.0 but with no margin. The split was server 1,344 MiB, database 640 MiB and Valkey 64 MiB. On the Actions runner all three runs on v3.3.5 finished the upload test (immich-no-ml-2g.json): 20 of 20 uploads processed, no failed job, all queues idle after 24.3 s (24.1 to 24.3), and no container had OOMKilled set. As on v3.3.3, immich-server did not restart in any run: every container had a restart count of 0, so no OOMKilled flag was reset by a restart. On v3.3.0 and v3.3.1 this stack restarted once in every run; on v3.3.3 the uncapped no-ML stack did instead, and on v3.3.5 neither did (table under Measured resources), so the cause, a start-order race, is not specific to the caps. The server’s peak under load was 1,162 MiB (1,126 to 1,274) against its 1,344 MiB limit, and the stack peaked at 1,536 MiB (1,501 to 1,644; 1,738 MiB at start-up). Postgres reached 588 MiB at start-up (474 to 622) against its 640 MiB limit, within 18 MiB in the highest run (within 15 MiB on v3.3.3 and within 2 MiB in one run on v3.3.1).

On the earlier sandbox host with v3.2.4 the same setup finished less often. We ran it 8 times on Oct 2 (5 times with the new harness, 3 times with the previous one, to rule out the new sampling as the cause). It finished the same upload test 3 times. The other 5 failed during setup, before any upload: Postgres hit its 640 MiB limit during the first start and was killed, and the server, which lost its database connection, exited and restarted once. On Oct 6 we ran it three more times there, and all three finished; in the third the database was OOM-killed at some point and the server restarted once, and the run still finished. In total, on that host, 6 of 11 attempts finished and 5 did not. Raw results for Oct 2 are in methodology-change-2026-10-02.md, section 4.1. The Actions runner results are 3 of 3 on Oct 8 (v3.3.0), 3 of 3 on Oct 15 (v3.3.1), 3 of 3 on Oct 21 (v3.3.3) and 3 of 3 on Oct 28 (v3.3.5). We do not know whether the version or the host explains the difference.

Measured readings

Test box: Immich (no machine learning, 2 GiB cap) v3.3.5

Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.

Idle RAM
1.0 GiBrange 1.0–1.3 · 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
Startup peak RAM
1.7 GiBrange 1.6–1.7 · 3 runs highest total between healthy and settled
Peak RAM
1.5 GiBrange 1.5–1.6 · 3 runs under load, median of the run peaks
Settled after
185 srange 165–192 · 3 runs after the first healthy response
Idle CPU
0.5 %range 0.4–2.9 · 3 runs of one core, lab host
Startup
9.3 srange 9.3–9.5 · 3 runs to first healthy response
App version
v3.3.5
Tested
, 3 runs (compose file verified the same day)
How the figures are made
Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
Lab host
Intel(R) Xeon(R) Platinum 8370C CPU @ 2.80GHz, 2 cores, 7.8 GiB RAM, x86_64.Ubuntu 24.04.5 LTS, Docker 28.0.4.
Disk for the images
About 3.8 GB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (our estimate: unpacked plus compressed size, plus 10%; not measured on a containerd host). About 2.6 GB with the older overlay2 store (the unpacked column, as measured on this lab host). Plan for the larger figure. How we size disk
How idle was measured
After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
Peak RAM measured
Under load. Upload 20 generated 4000x3000 JPEGs (about 1 MB each, synthetic gradients and shapes, no people) through the API as the admin user, then wait until every Immich background queue (thumbnails, metadata, CLIP smart search, face detection, ...) is empty. Machine learning is disabled and its container is not running. Every container has a hard memory limit; the limits add up to 2 GiB. Peak and mean are taken from the first upload until the queues are idle.
Per-container figures for Immich (no machine learning, 2 GiB cap): median over 3 runs, with the range
ContainerIdle RAMPeak RAM (under load)Image, compressed (download)Image, unpacked (disk, overlay2 store)
database360 MiBrange 357–364 · 3 runs368 MiBrange 364–370 · 3 runs205 MB756 MB
immich-server694 MiBrange 675–959 · 3 runs1.1 GiBrange 1.1–1.2 · 3 runs609 MB1.7 GB
redis5 MiBsame when rounded in all 3 runs6 MiBsame when rounded in all 3 runs48 MB123 MB
Total1.0 GiBrange 1.0–1.3 · 3 runs1.5 GiBrange 1.5–1.6 · 3 runs862 MB2.6 GB
Every run (3)
Total RAM, startup and CPU model of each run of Immich (no machine learning, 2 GiB cap)
RunIdle RAMPeak RAMStartup peakStartupLab host CPU
11.0 GiB1.6 GiB1.7 GiB9.3 sIntel(R) Xeon(R) Platinum 8370C CPU @ 2.80GHz
21.3 GiB1.5 GiB1.6 GiB9.5 sIntel(R) Xeon(R) Platinum 8370C CPU @ 2.80GHz
3 (closest to median idle)1.0 GiB1.5 GiB1.7 GiB9.3 sIntel(R) Xeon(R) Platinum 8370C CPU @ 2.80GHz
Total RAM after the stack became healthy (10 s averages, run 3 of 3)
Total RAM across all containers in 10 s averages, from the moment the stack was healthy until the end of the idle window (230 s). Run 3 of 3, the one closest to the median idle. Highest 10 s average 1.6 GiB at 20 s, last 1.0 GiB at 230 s. Dashed line: the stack counted as settled at 192 s.

0 s to 230 s after healthy; the line spans 0 to 1.6 GiB. Dashed line: settled.

Timeline as a table
Total RAM, 10 s average ending at each time, every 30 s after healthy
Seconds after healthyTotal RAM
301.4 GiB
601.4 GiB
901.4 GiB
1201.3 GiB
1501.0 GiB
1801.0 GiB
2101.0 GiB
2301.0 GiB

RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.

Lab notes (5)
  • Machine learning is disabled the way Immich's FAQ describes (https://docs.immich.app/FAQ#how-can-i-disable-machine-learning, read 2026-10-01): switched off under Administration > Settings > Machine Learning Settings (done through the API by disable_ml.py), and the immich-machine-learning section removed from compose.yaml so the container does not start.
  • Memory caps are compose `mem_limit` values per container (hard limits: a container over its limit is OOM-killed). Docs: https://docs.immich.app/FAQ#can-i-limit-cpu-and-ram-usage (read 2026-10-01). The split and its sum are in the header of compose.yaml. RestartCount and OOMKilled per container are in services.<name>.restart_count / oom_killed.
  • The .env adds IMMICH_HOST=0.0.0.0: the lab host has no IPv6, and Immich containers listen on [::] by default (the ML container crash-loops without it).
  • Same stack, .env and upload load as apps/immich (Immich v3 release image tags, 20 generated 4000x3000 JPEGs); the setup and upload scripts are shared with that app.
  • Hardware acceleration (GPU/iGPU) is not tested: the lab host has none.

The split mattered. We tried three on Oct 1 on the earlier host, and the first two failed before the load started (lab notes, section 4). The third is the split we then repeated:

Server limit (MiB) Database limit (MiB) Valkey limit (MiB) Outcome
1,472 512 64 Failed on Oct 1 (earlier host, v3.2.4). Postgres was killed for memory during the first-start geodata import, and the server exited.
1,216 768 64 Failed on Oct 1 (earlier host, v3.2.4). The server was killed for memory while starting and restarted once.
1,344 640 64 Worked on Oct 1 (once) and in 3 of 8 runs on Oct 2 and 3 of 3 on Oct 6 on the earlier host (v3.2.4); in the other 5 of those 11 runs the database was killed on first start, as in the first row. On the Actions runner it worked in 3 of 3 runs on v3.3.0 (Oct 8), 3 of 3 on v3.3.1 (Oct 15), 3 of 3 on v3.3.3 (Oct 21) and 3 of 3 on v3.3.5 (Oct 28): 20 of 20 uploads processed, no OOMKilled flag; one server restart per run on v3.3.0 and v3.3.1 (a refused database connection in the logged Oct 15 runs), none on v3.3.3 or v3.3.5.

So a 2 GiB budget leaves almost no choice in the split, that is for containers alone, and even the split that worked has little margin: 18 of 23 attempts across both hosts finished, and the database’s start-up peak sat within 2 MiB of its limit in one run (on v3.3.1). Our 2,048 MiB of limits is also more than a real 2 GB machine has (about 1.9 GiB), and the operating system takes a share of that. The no-ML stack’s start-up peak on our uncapped runs reached 2,117 MiB in the highest run (median 2,080 MiB), 69 MiB above the 2,048 MiB total of the caps (the capped stack’s own start-up peak was 1,738 MiB, median), and by our sizing rule it needs 4 GB. We would not run Immich on 2 GB. We did not run the full stack with machine learning at 2 GiB: its start-up peak on our uncapped run (2,145 MiB, median; 2,167 MiB in the highest run) is already above 2 GiB, and its peak under load was 3,701 MiB. Not tested in our lab: 2 GB with machine learning.

Why Immich RAM usage is high, and how to reduce it

High usage has four sources in our numbers, and they are not all permanent.

  • The machine-learning container. It is small until a job needs a model (204 MiB idle) and reached 2,055 MiB at its peak (median of three runs). By default Immich unloads idle models after 300 seconds: the environment variable docs list MACHINE_LEARNING_MODEL_TTL (“Inactivity time (s) before a model is unloaded”) with a default of 300. On a kept 4 GiB stack of v3.2.4 on the earlier host (Oct 1) the container fell from 775 MiB to 166 MiB about 5 minutes after its last model load. In the log the unload is a worker restart (Worker (pid:107) was sent SIGINT!), which Immich’s FAQ says is a feature to reduce RAM when the service is not used. We did not change the TTL value and did not repeat this on v3.3.0. Lab notes, section 5.
  • The server’s start-up phase. About 1.5 GiB for the first couple of minutes, then 0.7 GiB (immich.json: 1,442 MiB at start-up, 730 MiB settled, medians of three runs; section above). It also needs room to start: capped at 1,216 MiB it was killed on first start on Oct 1 (earlier host, v3.2.4), and at 1,344 MiB it started.
  • Postgres. Between 0.35 and 0.43 GiB at idle in every variant (360 to 443 MiB, medians), and the docs say its files are “typically between 1-3 GB in size” (requirements page).
  • The first import. Immich’s FAQ says the initial backup is the most intensive phase because many jobs run at once. Our 20-photo test is a small one.

What reduces it, and what we saw:

  1. Disable machine learning. The biggest lever we measured: 3,701 MiB to 1,670 MiB at peak, and 1,321 MiB to 1,090 MiB idle (medians of three runs). The cost, per the FAQ: “Disabling machine learning will result in a poor experience for searching and the ‘Explore’ page”. You can also turn off single models (for example only face recognition) in the same settings; not tested in our lab.
  2. Set a hard limit per container. The FAQ shows how and warns that “memory constraints work by terminating the container, so this can introduce instability if set too low”. Our caps did that on the earlier host: Postgres and the server were killed in the failed 2 GiB attempts, and the machine-learning container had an out-of-memory kill in all eight 4 GiB runs. On the Actions runner (v3.3.0, v3.3.1, v3.3.3 and v3.3.5) no container had the flag set in any of the twenty-four capped runs. The cap also lowered the server’s start-up peak: 1,209 MiB on the 4 GiB runs against 1,442 MiB uncapped on v3.3.5 (medians of three runs each; the two ran on different CPU models, EPYC 7763 and EPYC 9V45), and 1,200 MiB on the 2 GiB runs against 1,436 MiB for the uncapped no-ML stack (Intel Xeon 8370C and EPYC 7763). Its settled idle was about the same with and without the cap (743 MiB, range 727 to 752, against 730, range 727 to 732, for the 4 GiB pair; 694 MiB against 680 for the no-ML pair, where one capped run settled on a 959 MiB plateau), so we do not credit the cap with a change in settled idle. We do not know what the server would have done with that memory if it were free.
  3. Lower job concurrency. The FAQ lists “Lower the job concurrency for these jobs to 1” under lowering CPU and RAM use. We set Smart Search and Face Detection to 1 (default 2). On Oct 28, in three runs each, the median machine-learning peak was 1,934 MiB against 2,055 MiB (ranges 1,884 to 2,022 and 1,910 to 2,075, so they overlap), the stack peak 3,685 MiB against 3,701 MiB (3,613 to 3,811 against 3,538 to 3,802, overlapping), and the jobs took 48.8 s against 51.7 s (45.4 to 49.2 against 51.7 to 54.3, not overlapping; immich-ml-1job.json, immich.json), so they were faster, not slower. For the first time the two ran on the same CPU model (AMD EPYC 9V45), though on different runner images (kernel 6.17.0 for concurrency 1, kernel 7.0.0 for the default). The machine-learning container, which the setting targets, peaked lower with concurrency 1, but the server (1,338 MiB against 1,258) and Postgres (460 MiB against 388), which it does not, peaked higher, and so did the idle total (1,407 MiB against 1,321, of which Postgres 443 against 380 and Valkey 12 against 6). On Oct 21 the same comparison gave 1,591 MiB against 1,957 MiB for machine learning and 3,205 MiB against 3,685 MiB for the stack, with the jobs taking 42.6 s against 57.6 s, on AMD EPYC 9V45 and Intel Xeon 6973P-C. On Oct 15 it gave 1,552 MiB against 1,590 MiB for machine learning and 3,188 MiB against 3,349 MiB for the stack (3,187 to 3,220 against 3,348 to 3,635, no overlap), with the jobs taking 57.6 s against 48.2 s, on Intel Xeon Platinum 8370C and EPYC 9V74. On Oct 8 it went the other way: 1,864 MiB against 1,847 MiB for machine learning and 3,557 MiB against 3,546 MiB for the stack, with the ranges overlapping. The one-run comparisons on the earlier host on Oct 1 and Oct 2 went in both directions (lab notes, section 7), and so did the Oct 6 three-run comparison there (1,924 MiB against 1,938 MiB for machine learning). Across the five three-run comparisons the machine-learning peak with concurrency 1 differed from the default by -14, +17, -38, -366 and -121 MiB (Oct 6, 8, 15, 21 and 28). Two are above the roughly 100 MiB we treat as noise; in both the ranges overlap, and the Oct 21 pair ran on different CPU models. The stack-level difference was +11, -161, -480 and -16 MiB on Oct 8, 15, 21 and 28. So the machine-learning peak was lower with concurrency 1 in the last three batches, but we have no comparison on one runner image and the stack-level difference is small this time, so we do not credit the setting.
  4. Use a smaller face model or move machine learning elsewhere. The FAQ says to change the facial recognition model to buffalo_s, “a smaller and faster model”, and to re-run Face Detection afterward. It also says you can run the machine-learning container on another machine. Not tested in our lab: both. v3.3.0 also adds an opt-in model revision that its notes describe as using less memory (see “What changed in v3.3.0, v3.3.1, v3.3.3, v3.3.4 and v3.3.5”); we did not run it.

The concurrency-1 run from item 3, with its three runs side by side:

Measured readings

Test box: Immich (ML job concurrency 1) v3.3.5

Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.

Idle RAM
1.4 GiBrange 1.3–1.4 · 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
Startup peak RAM
2.2 GiBrange 2.1–2.3 · 3 runs highest total between healthy and settled
Peak RAM
3.6 GiBrange 3.5–3.7 · 3 runs under load, median of the run peaks
Settled after
176 srange 176–265 · 3 runs after the first healthy response
Idle CPU
1.6 %range 1.4–1.6 · 3 runs of one core, lab host
Startup
9.1 srange 8.9–9.3 · 3 runs to first healthy response
App version
v3.3.5
Tested
, 3 runs (compose file verified the same day)
How the figures are made
Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
Lab host
AMD EPYC 9V45 96-Core Processor, 2 cores, 7.8 GiB RAM, x86_64.Ubuntu 24.04.5 LTS, Docker 28.0.4.
Disk for the images
About 4.9 GB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (our estimate: unpacked plus compressed size, plus 10%; not measured on a containerd host). About 3.3 GB with the older overlay2 store (the unpacked column, as measured on this lab host). Plan for the larger figure. How we size disk
How idle was measured
After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
Peak RAM measured
Under load. Upload 20 generated 4000x3000 JPEGs (about 1 MB each, synthetic gradients and shapes, no people) through the API as the admin user, then wait until every Immich background queue (thumbnails, metadata, CLIP smart search, face detection, ...) is empty. Smart Search and Face Detection run one job at a time (concurrency 1, default 2). The machine-learning container really runs; the images contain no faces, so face recognition has nothing to find. Peak and mean are taken from the first upload until the queues are idle.
Per-container figures for Immich (ML job concurrency 1): median over 3 runs, with the range
ContainerIdle RAMPeak RAM (under load)Image, compressed (download)Image, unpacked (disk, overlay2 store)
database443 MiBrange 385–460 · 3 runs460 MiBrange 397–468 · 3 runs205 MB756 MB
immich-machine-learning203 MiBrange 202–210 · 3 runs1.9 GiBrange 1.8–2.0 · 3 runs268 MB738 MB
immich-server738 MiBrange 735–750 · 3 runs1.3 GiBrange 1.2–1.3 · 3 runs609 MB1.7 GB
redis12 MiBrange 10–12 · 3 runs13 MiBrange 13–14 · 3 runs48 MB123 MB
Total1.4 GiBrange 1.3–1.4 · 3 runs3.6 GiBrange 3.5–3.7 · 3 runs1.1 GB3.3 GB
Every run (3)
Total RAM, startup and CPU model of each run of Immich (ML job concurrency 1)
RunIdle RAMPeak RAMStartup peakStartupLab host CPU
11.3 GiB3.6 GiB2.2 GiB9.1 sAMD EPYC 9V45 96-Core Processor
21.4 GiB3.7 GiB2.1 GiB9.3 sAMD EPYC 9V45 96-Core Processor
3 (closest to median idle)1.4 GiB3.5 GiB2.3 GiB8.9 sAMD EPYC 9V45 96-Core Processor
Total RAM after the stack became healthy (10 s averages, run 3 of 3)
Total RAM across all containers in 10 s averages, from the moment the stack was healthy until the end of the idle window (210 s). Run 3 of 3, the one closest to the median idle. Highest 10 s average 2.1 GiB at 100 s, last 1.4 GiB at 210 s. Dashed line: the stack counted as settled at 176 s.

0 s to 210 s after healthy; the line spans 0 to 2.1 GiB. Dashed line: settled.

Timeline as a table
Total RAM, 10 s average ending at each time, every 30 s after healthy
Seconds after healthyTotal RAM
302.1 GiB
602.1 GiB
902.1 GiB
1201.7 GiB
1501.4 GiB
1801.4 GiB
2101.4 GiB

RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.

Lab notes (4)
  • Warning: immich-server restarted 1 time(s) during the run (run 1 of 3)
  • Same stack, .env and upload load as apps/immich; the only change is job concurrency 1 for Smart Search and Face Detection, set through the admin settings API (set_concurrency.py). Docs: https://docs.immich.app/FAQ#can-i-lower-cpu-and-ram-usage (read 2026-10-01).
  • The .env adds IMMICH_HOST=0.0.0.0: the lab host has no IPv6, and the ML container binds [::] by default and crash-loops without it.
  • Hardware acceleration (GPU/iGPU) is not tested: the lab host has none.

Our numbers against the official requirements

Immich’s requirements page says “RAM: Minimum 6GB, recommended 8GB”, and for “systems with only 4GB of RAM, Immich can be run with machine learning features disabled”. It also says: “if Docker resource limits are used, the Postgres database requires at least 2GB of RAM”.

Official statement What we measured Match
6 GB minimum, 8 GB recommended Full stack: 3.6 GiB peak, 8 GB by our 1.5x rule Our rule lands on the recommended size; the stack itself used about 65% of 6 GB
4 GB works with machine learning disabled No-ML stack: 2.1 GiB highest reading (at start-up, in the highest run), 1.6 GiB under load; 4 GB by our rule Consistent with it; our limits are not a real 4 GB host
Postgres needs at least 2 GB under Docker limits Postgres at a 640 MiB limit (360 MiB mean at idle, 368 MiB at its load peak, medians of the three Oct 28 runs) started in 3 of 3 runs on v3.3.5, v3.3.3 and v3.3.1, with a start-up peak within 18 MiB of the limit in the highest run on v3.3.5, within 15 MiB on v3.3.3 and within 2 MiB in one run on v3.3.1; on the earlier host (v3.2.4) it was killed on first start in 5 of 11 runs, and at 512 MiB on Oct 1 Mixed: the doc’s 2 GB was not needed to start in the Actions runs, and the same limit failed often on the earlier host. We would not rely on 640 MiB, and our library is 20 photos

Why our numbers are lower than the doc’s 6 GB:

  • Different thing measured. The doc’s number is for a host. Ours is the sum of the four containers’ working sets. The operating system, Docker and file cache come on top, which is what our 1.5x factor stands in for.
  • A small load. 20 photos with no faces and no video. A real first import adds face recognition on real faces, video transcoding and thousands of assets. We did not measure those, so the doc’s headroom may be justified by them.
  • Defaults. Our run used Immich’s default job concurrency and default model settings; we did not set MACHINE_LEARNING_MODEL_REVISION. On v3.2.4 the models were ViT-B-32__openai for search, buffalo_l for faces and PP-OCRv5_mobile for text; we did not re-read the model names on v3.3.0 or v3.3.1.

What we add to the doc: machine learning accounts for a little over half of the load peak (the median peaks with and without it differ by 2,031 MiB of 3,701 MiB), and a 4 GiB budget with machine learning on lost a machine-learning worker in all eight runs on the earlier host and in none of twelve on the Actions runner (three each on v3.3.0, v3.3.1, v3.3.3 and v3.3.5), where the container peaked 171 MiB under its limit in the median run of v3.3.5 and 94 MiB under in the highest (30 and 27 MiB on v3.3.3, 5 and 2 MiB on v3.3.1). That is a result for one test, not a safe setting.

What we did not measure

  • Libraries of thousands of photos, any video transcoding, and face recognition on real faces (our images contain none).
  • A real 4 GB or 2 GB machine. We capped containers on an 8 GB runner, so the operating system’s share is missing.
  • The full stack with machine learning at 2 GiB.
  • A lower MACHINE_LEARNING_MODEL_TTL, the buffalo_s model, the v3.3.0 v2 model revision, remote machine learning, hardware acceleration (the host has no GPU), ARM hosts.
  • Memory growth over days. Our longest watch was 10 minutes, on the earlier host. The harness timelines end 210 to 300 s after healthy, so a change later than that is not in them.
  • Other memory splits for the 4 GiB run. We ran one.
  • Whether condition: service_healthy removes the immich-server restart in the no-ML stack. We did not run it. We have logs of fourteen restarts (Oct 10, Oct 15, Oct 21 and Oct 28, all a refused database connection); the six restarts in the Oct 8 runs on v3.3.0 had no logs.
  • Other apps on the same host. We measured Immich alone. A second app adds its own figure: Vaultwarden behind Caddy idled at 22 MiB and peaked at 67 MiB (medians of three runs, Vaultwarden 1.37.5) in a separate lab run. We did not run the two stacks together. A Nextcloud file-server stack with Postgres, Redis and cron (see Nextcloud Docker Compose) idled at 297 MiB and peaked at 452 MiB (medians of three runs) under a one-user upload in its own lab run; we did not run it next to Immich either. Seafile 13.0.28 (three containers) and ownCloud Infinite Scale 8.2.2 (one container) idled at 616 MiB and 151 MiB in their own runs; see Nextcloud vs ownCloud vs Seafile for the three file servers side by side.

Gotchas, upgrade and backup

  • A killed worker looks healthy. In the 4 GiB runs on the earlier host the machine-learning container never stopped and its restart count stayed 0, yet OOMKilled was true and a worker had been killed. Check docker logs immich_machine_learning for SIGKILL, not only docker ps. The FAQ says SIGKILL or error code 137 “most likely means the service is running out of memory”. The three 4 GiB runs on v3.3.5 (and the three each on v3.3.3, v3.3.1 and v3.3.0) had the flag false.
  • OOMKilled resets when a container restarts. In the second failed 2 GiB attempt (Oct 1, earlier host) the server was killed for memory (Docker’s event log showed oom immich_server, exit code 137) and restarted, and the end-of-run check then reported OOMKilled=false. The restart count (1) was the evidence. Read both fields; our lab now records both. It matters for the runs where the server restarted: a restart count of 1 with OOMKilled=false does not on its own tell a memory kill from another cause, which is why the harness now saves the log when it first sees a restart. In all thirteen restarts of the Oct 15, Oct 21 and Oct 28 runs the log shows a refused database connection at start-up, not a kill (see Measured resources).
  • First start needs more memory than steady state. The failed 2 GiB attempts on the earlier host died on first start, before any upload (on Oct 1 during the geodata import; on Oct 2 the database was killed in 5 of 8 runs; on Oct 6 setup finished in all 3 runs, though run 3 recorded a database kill and a server restart at a point we did not capture). On the Actions runner all three 2 GiB runs set up and finished. Our server’s start-up peak was 1.1 to 1.5 GiB against 0.7 GiB settled. If you cap memory, size the limits for the first two minutes, not for idle.
  • mem_limit is a hard limit. Put it only on the services you mean to cap, and keep the sum under the host’s RAM with space left for the operating system.
  • Upgrade and backup are covered, with the commands we ran, in Update safely and Back up and restore the database in the setup guide. Re-check RAM after an upgrade: these numbers are v3.3.5 only.

Where to run it

  • Hardware. Immich idled at 1.3 GiB and peaked at 3.6 GiB under load (medians of 3 runs) in our lab. The highest reading in any run was 3.7 GiB. Plan for at least 8 GB of RAM, sized from the highest run. See how much RAM self-hosted apps use.
  • VPS. The smallest plan that runs this comfortably has 8 GB of RAM, plus disk for your data and the images. Plan for about 4.9 GB for the images (Docker 29 and later with the containerd image store, the default on fresh installs; 3.3 GB with the older overlay2 store).
  • Keep it safe. Back up the data volume before you rely on it, and put the app behind a reverse proxy with HTTPS before you expose it to the internet. See backing up self-hosted apps.

How we size: recommended RAM is the highest reading in any of our runs (under load or during startup, not the median) times 1.5, rounded up to the next of 1, 2, 4, 8, 16 or 32 GB. The extra half covers the operating system, Docker, file cache and spikes our sampling can miss. Your own data and extra apps need more. Disk for images: Docker Engine 29 and later uses the containerd image store on fresh installs, which keeps each image twice (as downloaded and unpacked); older installs use overlay2, which keeps it unpacked only. We plan for the larger figure: unpacked plus compressed size, plus 10%, rounded up. Your data volumes and growth come on top.

Update log

  • Updated the Vaultwarden figures in the list of things we did not measure to the 1.37.5 re-test of Nov 3 (22 MiB idle, 67 MiB peak; was 25 and 70). No Immich measurements changed.
  • Added a link to the new RAM data piece (how much RAM self-hosted apps need) in the Related list. No measurements or text changed.
  • Re-tested on Immich v3.3.5 (was v3.3.3), median of 3 runs on Oct 28, same runner type but a different CPU model in three of the five stacks (and two runner images: kernel 7.0 for two stacks, 6.17 for three); no config changes (Immich tags and digests only). Full stack: idle 1,321 MiB (was 1,324), peak 3,701 (was 3,685); no ML: idle 1,090 (was 1,118), peak 1,670 (was 1,699). Sizing is unchanged: 8 GB with ML, 4 GB without. The 4 GiB cap killed no container in 3 of 3 runs, and the ML container peaked 171 MiB under its limit in the median run and 94 MiB under in the highest (30 and 27 MiB on v3.3.3; 5 and 2 on v3.3.1), so the page now says the margin is wider but still not safe; the 2 GiB no-ML stack finished 3 of 3 (its database came within 18 MiB of its limit at start-up). Server restarts: 2 of 15 runs, both in run 1 (the full and concurrency-1 stacks), both a refused database connection and no memory kill; the no-ML, 4 GiB and 2 GiB stacks had none (a table of the four batches replaces the three). Concurrency 1 and the default ran on the same CPU model (AMD EPYC 9V45) for the first time, on different runner images: ML peak 1,934 MiB against 2,055 (overlapping ranges), jobs 48.8 s against 51.7; the page still does not credit the setting. In run 2 of the 2 GiB stack the server settled on a plateau of 959 MiB (675 and 694 MiB in the other runs), which widens that row's idle range. v3.3.5 (Oct 21) is a security release: two dependency updates under Security, a fix for the CA compromise of that day and Node.js security patches, per the release notes as a web-fetch tool returned them (unverified); v3.3.4 (Oct 20) fixed a translation and made person queries more efficient and was not run on its own. The concurrency-1 and no-ML results now have their own Test boxes and are in the page's lab results (before, they were in the table only).
  • Re-tested on Immich v3.3.3 (was v3.3.1), median of 3 runs, same runner type but different CPU models (and a newer runner image, kernel 7.0 on four of the five stacks); no config changes (Immich tags and digests only). Full stack: idle 1,324 MiB (was 1,424), peak 3,685 (was 3,349); no ML: idle 1,118 (was 1,106), peak 1,699 (was 1,677). Sizing is unchanged: 8 GB with ML, 4 GB without. The 4 GiB cap killed no container in 3 of 3 runs (the ML container peaked 30 MiB under its limit in the median run and 27 MiB in the highest; 5 and 2 MiB on v3.3.1) and the 2 GiB no-ML stack finished 3 of 3. Server restarts: 5 of 15 runs, in 3 of the 5 stacks (all three uncapped no-ML runs, one run each of the full and concurrency-1 stacks, none of the capped runs). All five logs show the same refused database connection and no memory kill, so the explanation stands; the stacks that restart in every run differ from batch to batch (a table of the three batches replaces the single-batch counts), and the page no longer says the uncapped no-ML stack had no restart. The concurrency-1 comparison and the CPU models (now Intel Xeon 6973P-C and AMD EPYC 9V45 for the first two rows) were updated. The v3.3.3 notes list two fixes, one a people-query performance change, and no breaking change, security fix or migration. v3.3.4 (Oct 20) was released before our runs and was not tested. The restart section now notes that all five restarts in the stacks with machine learning were in run 1 of the three, and the concurrency-1 paragraph gives the four batch differences instead of saying it made no measurable difference.
  • Linked the new Nextcloud vs ownCloud vs Seafile page from the list of things we did not measure (other file servers on the same host). No measurements changed.
  • Re-tested on Immich v3.3.1 (was v3.3.0), median of 3 runs, same runner type; no config changes (Immich tags and digests only). Full stack: idle 1,424 MiB (was 1,380), peak 3,349 (was 3,546); no ML: idle 1,106 (was 1,104), peak 1,677 (was 1,646). Sizing is unchanged: 8 GB with ML, 4 GB without. The 4 GiB cap killed no container in 3 of 3 runs (the ML container peaked 5 MiB under its limit in the median run and 2 MiB in the highest; the median was 13 MiB under on v3.3.0) and the 2 GiB no-ML stack finished 3 of 3. The restart explanation changed: the harness logged all 6 immich-server restarts (6 of 15 runs, in 4 of the 5 stacks, with and without ML); each was a refused database connection, none a memory kill, so the section no longer says the restart is specific to the no-ML stack. The concurrency-1 comparison and the CPU models (now also an Intel Xeon Platinum 8370C) were updated.
  • Explained the single immich-server restart in the no-ML runs: a diagnostic run on Oct 10 logged a refused database connection at server start-up (a start-order race, harmless with restart: always). The six published runs had no logs, so the cause there is an inference. Added an untested depends_on suggestion. No numbers changed.
  • The Where to run it module now sizes image disk for both Docker image stores (about 4.9 GB with the containerd store, 3.3 GB on overlay2; was 3.3 GB only). No new measurements; the RAM figures are unchanged.
  • Re-tested on Immich v3.3.0 (was v3.2.4) on our new standard lab host (GitHub Actions runner, 2 vCPU / 8 GB), median of 3 runs; the earlier numbers came from a sandbox host with 4 vCPU and 15.7 GiB, so version and host changed together. Full stack: idle 1,380 MiB (was 1,321), peak 3,546 (was 3,454); no ML: idle 1,104 (was 1,118), peak 1,646 (was 1,517). Sizing is unchanged: 8 GB with ML, 4 GB without. Memory caps re-counted from the new runs: the 4 GiB cap killed the ML worker in 0 of 3 runs (8 of 8 on the earlier host); the 2 GiB no-ML stack finished 3 of 3 runs with no OOM flag on any container (6 of 11 on the earlier host), but immich-server restarted once in every no-ML run, capped or not. Release-note points for v3.3.0 added.
  • All five Immich results re-measured as the median of 3 runs (methodology change 2026-10-06), same v3.2.4 and image digests. Full stack: idle 1,321 MiB (range 1,316 to 1,370), peak 3,454 MiB (range 3,303 to 3,458); no ML: idle 1,118, peak 1,517; sizing still 8 GB with ML and 4 GB without. The 4 GiB cap again killed the ML worker in all 3 new runs (8 of 8 in total) but a smart search returned all 20 images in all three, so the earlier 14 of 20 is now 1 run in 8. The 2 GiB no-ML stack finished 3 of 3 new runs (one with a database kill and a server restart), against 3 of 8 on Oct 2, so 6 of 11 in total. Concurrency 1 still did not lower RAM measurably. Vaultwarden and Nextcloud figures in the list of things we did not measure updated to their new medians.
  • Updated the Vaultwarden figures in the list of things we did not measure to the 1.37.4 re-test (22 MiB idle, 84 MiB peak; was 24 and 83). No Immich measurements changed.
  • Linked the new Nextcloud Docker Compose page from the list of things we did not measure (other apps on the same host). No measurements changed.
  • The downloadable .env files no longer carry the lab's database password: DB_PASSWORD is the placeholder CHANGE_ME_DB_PASSWORD. The lab ran with the old value; measurements are unchanged.
  • Linked the new Vaultwarden Docker Compose page from the list of things we did not measure (other apps on the same host).
  • Simplified the page: two variants moved into the summary table.
  • Re-tested all five runs under the new idle-RAM method (we now wait for memory to settle before measuring idle). Full-stack idle is 1,364 MiB, was 2,162; no-ML idle 1,120, was 1,919. Full-stack peaks moved by 3% or less (3,409 MiB, was 3,324); the no-ML peak under load is 1,520 MiB (was 1,662) and the 2 GiB run's 1,522 MiB (was 1,730). The 2 GiB no-ML run now fails on first start in 5 of 8 attempts; the 4 GiB run lost the ML worker in all 5 runs.
  • First published. Five lab runs on Immich v3.2.4: full stack, machine learning off, 4 GiB and 2 GiB memory caps, and ML job concurrency 1.