Skip to content

Requirements and sizing

This page lists what you need before you install Aperture and helps you size the server and the disks. Read it once before you buy hardware; the storage table near the end answers the most common question, “how big a disk do I need?”

You need Details
A server A 64-bit x86 (x86-64) machine running Linux with systemd. A mini PC, a NUC, an old laptop or a virtual machine all work. ARM boards such as a Raspberry Pi are not supported: the installer stops on anything that is not x86_64.
An operating system Debian 13 is what Aperture is developed and run on. Debian and Ubuntu are the easy path because the installer uses apt and the GPU setup guide knows their package names.
CPU and memory Depends mostly on motion detection and object recognition, not on recording. See CPU and memory.
Storage A disk for footage sized to the history you want. See Storage.
Cameras Cameras that offer an RTSP stream, ideally with a second, smaller “sub stream”. See Cameras.
A network The server must reach each camera’s RTSP port. Wired Ethernet for the server, fixed addresses for server and cameras.
A browser A current Chrome, Edge, Firefox or Safari.
Internet access To install and update (downloads from GitHub, npm and the Go module proxy), and for the optional features listed under Network. Running Aperture does not need it.

Optional extras: a reverse proxy for HTTPS (needed for installing the app on a phone, push notifications and passkeys, see HTTPS and remote access), an MQTT broker or Home Assistant, a NAS for network storage, and an NVIDIA GPU for faster object recognition.

  • Architecture. x86-64 only. deploy/install.sh checks uname -m and refuses anything else.
  • systemd. Aperture runs as three systemd services and uses systemd-sysusers and systemd-tmpfiles to create its users and folders. A system without systemd cannot run the installer.
  • Distribution. On Debian and Ubuntu the installer installs its packages (ca-certificates, mosquitto, ffmpeg) with apt. On other distributions it prints the list and expects you to install them yourself; that path is not tested.
  • Virtual machines. A VM is fine. Give it the CPU cores and memory you would give a physical box, and put footage on a virtual disk or a passed-through disk that is not shared with busy workloads.
  • Build tools. Aperture is built on the server itself: you need Go 1.25 or newer and Node.js 18 or newer for the build. Install has the commands.
  • No avahi. The avahi-daemon package must not be installed. It holds the mDNS port that Aperture’s network advertisement and the HomeKit bridge need, and the installer refuses to run while it is present.

Recording costs almost nothing: Aperture copies each camera’s stream to disk without re-encoding it. Live view is relayed as the camera sends it, without transcoding. What costs CPU and memory is anything that has to decode the picture.

Work Cost
Recording (stream copy) Near zero per camera.
Live view Small. The video is relayed, not converted.
Motion detection on a sub stream Small. Motion only looks at a 64×36 grid, five times a second.
Motion detection without a sub stream Expensive. Aperture has to decode the full-resolution main stream; a 4K H.265 camera measured more than one CPU core and about half a gigabyte of memory. Give every camera a sub stream.
Lower recording quality (re-encode) About one CPU core per camera; a 4K camera measured about 1.3 cores and 0.7 GB. Only cameras where you set Recording quality in the camera editor pay this.
Object recognition on the CPU Depends on the model. One inference uses half the CPU threads the service may use, between one and four.
Object recognition on an NVIDIA GPU Little CPU; about 1 GB more memory for the GPU worker.

As a reference point, four cameras recording around the clock, with motion detection on their sub streams, run on a machine with 4 CPU cores and 4 GB of RAM. Add cores for object recognition on the CPU and memory for a GPU worker.

Settings › Hardware shows a camera-capacity estimate for your machine; Camera capacity explains the model behind it.

The aperture systemd unit caps the daemon and everything it starts (ffmpeg, the recognition worker, extensions):

Limit Value
CPUQuota 600% (six cores)
MemoryHigh 4608M (the kernel starts reclaiming memory here)
MemoryMax 5G (hard ceiling)
TasksMax 1024

On a smaller machine these never bind. On a bigger one, Aperture will not use more than six cores and 5 GB unless you raise the limits with a systemd drop-in, which survives reinstalls:

Terminal window
sudo systemctl edit aperture
[Service]
CPUQuota=1200%
MemoryHigh=9G
MemoryMax=10G

Then sudo systemctl restart aperture. The web app shares these limits with the recorders, so a service at its ceiling feels slow everywhere; Troubleshooting shows how to check.

Object recognition runs on the CPU out of the box. An NVIDIA GPU makes it much faster and unlocks the larger models. What Aperture needs:

  • An NVIDIA GPU from Pascal (GTX 10 series) to Blackwell (RTX 50 series). Aperture downloads ONNX Runtime 1.31 with CUDA 12.9 and cuDNN 9.28, which cover that range.
  • The NVIDIA driver installed on the machine. It is the only part you install yourself; Aperture never installs a driver. It needs the driver loaded and its CUDA library (libcuda.so.1) present. Settings › Detection shows a step-by-step GPU setup guide with the exact commands for Debian 12 and 13 and Ubuntu 22.04, 24.04 and 26.04.
  • The right kernel modules for your card. Blackwell cards (RTX 50) work only with NVIDIA’s open kernel modules and driver 570 or newer. Turing (RTX 20, GTX 16) and newer can use the open modules, which NVIDIA recommends. Pascal and Volta need the proprietary modules of the 580 driver branch.
  • The card visible to the operating system. In a virtual machine, that means passing the GPU through to the VM.
  • Disk space for the runtime. The GPU runtime is about a 3 GB download into /var/lib/aperture/ai, and Aperture wants three times the download size free before it starts unpacking. The CPU runtime is about 11 MB.

AMD GPUs are detected but not used; recognition then runs on the CPU. Instead of the built-in recognition you can also point Aperture at an external DeepStack-style detection server. See Object recognition.

Footage size depends on each camera’s bitrate, which you set in the camera’s own settings. Aperture records the main stream as the camera sends it, so the bitrate on disk is the camera’s bitrate. One megabit per second is about 10.8 GB per day.

Main stream bitrate Per camera per day 7 days 30 days
1 Mbit/s 11 GB 76 GB 324 GB
2 Mbit/s (720p to 1080p, modest) 22 GB 151 GB 648 GB
4 Mbit/s (typical 1080p to 4 MP) 43 GB 302 GB 1.3 TB
6 Mbit/s (4 to 5 MP) 65 GB 454 GB 1.9 TB
8 Mbit/s (4K H.264) 86 GB 605 GB 2.6 TB
16 Mbit/s (high-bitrate 4K) 173 GB 1.2 TB 5.2 TB

Multiply by the number of cameras. Four cameras at 4 Mbit/s kept for 14 days need about 2.4 TB.

Things that change the number:

  • Codec. H.265 is often around half the bitrate of H.264 for the same picture.
  • Motion-only recording keeps only footage that overlaps an event (with its pre- and post-roll), so it uses a fraction of continuous recording. How much depends on how busy the scene is.
  • Headroom. Without an allocation, Aperture’s free-space safety net keeps at least 7% of the disk free (at least 5 GiB on all but very small disks) and deletes the oldest footage to stay there. With an allocation, the database, thumbnails and exports count against it too. Plan for 10 to 15% more than the table says.

Once cameras are running, the dashboard’s Real-time Bitrate card shows what they actually send, and the usage bar in Settings › Recording & Storage splits the footage by camera. See Storage for allocations, retention and network destinations.

  • Footage disk. A 24/7 recording workload writes all the time. A surveillance-class drive (such as WD Purple or Seagate SkyHawk) is built for that. Use a Linux filesystem such as ext4 or XFS: the hard storage reservation preallocates space with fallocate.
  • System disk. The operating system, the database and the object-recognition files can live on a small SSD. The database grows with the number of events and segments, not with the size of the footage.
  • Where it mounts. The service may only write below /var/lib/aperture. Mount a footage disk at /var/lib/aperture/recordings (or below /var/lib/aperture for an extra local destination). Install shows how.
  • A NAS. Record to an SMB or SFTP share by adding it as a network destination in the app. Footage is written locally first and uploaded, so a network blip does not interrupt recording. See Storage.
  • Server to cameras. The server must reach each camera’s RTSP port (usually TCP 554). If you use ONVIF picture settings, it also needs the camera’s ONVIF port. Cameras do not need internet access for Aperture.
  • Wired and fixed. Use wired Ethernet for the server and, ideally, the cameras. Give the server and every camera a fixed address (a DHCP reservation in your router is enough), so camera links and bookmarks keep working.
  • Bandwidth. Each camera’s stream reaches the server once; recording, motion detection and viewers share it. The LAN load is the sum of your cameras’ bitrates plus what viewers watch. A gigabit network is plenty for a home system.
  • Outbound connections. Only for features you turn on: weather and location search (Open-Meteo), map tiles (OpenStreetMap), push notifications (your browser vendor’s push service), notification channels such as ntfy or Telegram, and the object-recognition downloads (GitHub, NVIDIA, Hugging Face).

Aperture’s services listen on these ports. The installer checks that 8971, 1883, 1984, 8554 and 8555 are free before it installs.

Port Protocol Used by Listens on Notes
8971 TCP Web app and API (nvrd) All interfaces Set by APERTURE_HTTP_ADDR. Your browser and your reverse proxy connect here.
1984 TCP go2rtc API 127.0.0.1 only Hands out every camera’s address and password, so only nvrd on the same machine may reach it. Never expose it.
8554 TCP go2rtc RTSP restream All interfaces Home Assistant, VLC and other recorders pull camera streams here. It has no password of its own.
8555 TCP and UDP go2rtc WebRTC All interfaces Live video in the browser over WebRTC.
1883 TCP Mosquitto MQTT broker Mosquitto’s own configuration Installed by the installer for the Home Assistant integration; Aperture does not change its configuration.
5353 UDP mDNS (aperture-discovery, HomeKit) LAN interfaces Advertises aperture.local.
10101 TCP ONVIF provider All interfaces Only when Integrations › ONVIF & HomeKit turns it on. No login.
3702 UDP ONVIF WS-Discovery All interfaces Only with the ONVIF provider on.
(random) TCP HomeKit bridge All interfaces Only when HomeKit is on; the port is picked when the bridge starts.

If the server runs a firewall, allow 8971 from the LAN, 8554 from the machines that consume the restream, 8555 TCP and UDP for WebRTC, and 5353 UDP for discovery. Do not forward any of these ports from the internet; see HTTPS and remote access.

Device Browsers
Desktop Current Chrome, Edge, Firefox or Safari
Phone and tablet Safari or Chrome

Some features need HTTPS, which a plain http://192.168.1.10:8971 address is not: installing Aperture as an app, push notifications that arrive while the app is closed, and passkeys. Everything else works over plain HTTP on your LAN.

H.265 (HEVC) cameras record fine, but whether a browser can play H.265 live and in playback depends on the browser, the operating system and the graphics hardware. If a camera can send H.264, test whether your browsers need it before you settle on H.265; see Troubleshooting.

Install · Camera capacity · Storage · Object recognition