# Migrating from Frigate to Fregata

If you've been running [Frigate](https://docs.frigate.video/) in
Docker on a Mac (Docker Desktop, OrbStack, Colima, …), this page
is the walkthrough for switching to a native
Fregata install. Most of your config carries over unchanged.
The bits that change are the parts that were Linux-shaped to
begin with — detectors, hardware-acceleration flags, paths.

## Why migrate

Running Frigate in Docker on a Mac forces every frame through a
Linux VM that doesn't have access to:

- The **Apple Neural Engine** — no detector accelerator inside
  the VM means object detection runs on the CPU at >50 ms / frame.
- **VideoToolbox** — H.264 / HEVC decode and encode happen on
  the CPU, not the dedicated media engine.

A native Fregata install gets both. Detection drops to ~1–2 ms
per frame on the ANE. Decode and encode move to the media engine.
On a 6-camera 2160p install, the CPU usage difference is dramatic
— typically 60-70% → 7-8% **while running object detection at full resolution! No separate sub-streams for detection!**

## Before you start

Spend a few minutes inventorying the existing Docker setup so
each step has a known target.

- **Where is `config.yml` on the Mac filesystem?** Check the
  `volumes:` section of your Docker Compose file — look for
  the host path mapped to `/config`. Common spots are
  `~/docker/frigate/config`, `/Volumes/Storage/frigate/config`,
  or wherever your stack put it.
- **Where are recordings?** Same treatment — find the host path
  mapped to `/media/frigate`. Often a separate volume on a
  larger drive or a network share.
- **What detector are you using?** Open `config.yml` and look at
  the `detectors:` block.
- **Are you using a custom model?** `model.path` or a `plus://`
  Frigate+ identifier in `config.yml`.
- **What's wired up?** MQTT (which broker?), Home Assistant
  (where is it running, what URL is it pointing at?), reverse proxy,
  push services.

Write the answers down or just keep the Docker Compose file open
in another window. You'll need them in steps 3 and 6.

## Step 1: Stop Frigate cleanly

From the directory holding your `docker-compose.yml`:

```bash
docker compose down
```

Wait for the container to exit before going further. If you have
a long-running event in progress, give it a moment — Frigate
flushes the active recording to disk on shutdown, and a `kill -9`
during that window leaves a zero-byte segment.

If you're running Frigate as a stand-alone container without
Compose:

```bash
docker stop frigate && docker rm frigate
```

Don't delete the volumes yet. We'll need them in step 3, and
they're a free safety net if you decide to roll back.

## Step 2: Install and activate Fregata

Follow [Installation](/getting-started/installation/) to drag
Fregata to Applications and grant the local-network permission,
then [Activation](/getting-started/activation/) to enter your
license (or start a 30-day trial).

This will bring you to the Fregata Welcome Dialog where you can set some initial settings.

## Step 3: Move your data

You have two choices. Pick whichever maps to how your storage is
laid out today.

### Path A: Point Fregata at your existing Docker host paths

Best if your Docker volumes already live on a fast SSD that
you're happy with — there's no point in copying data around.
On Fregata's Welcome Dialog:

1. **Config folder** — pick the
   host path that was mapped to `/config` (e.g.
   `~/docker/frigate/config`).
2. **Media Folder** — pick the
   host path that was mapped to `/media/frigate`.

Fregata reads from the chosen paths in place. Your existing
`config.yml`, the SQLite events database, recordings, clips, and
Frigate+ model cache all stay where they are.

### Path B: Move data into the standard `~/Fregata/` layout

Best if your old Docker volumes lived somewhere awkward
(`/var/lib/docker/...` inside the VM, an external drive you'd
rather decommission, etc.) and you'd like a clean local layout.

```bash
# Where Fregata expects to find things by default
mkdir -p ~/Fregata/config ~/Fregata/media

# Adjust the source paths to wherever your Docker volumes are
rsync -aH --info=progress2 /path/to/old/config/  ~/Fregata/config/
rsync -aH --info=progress2 /path/to/old/media/   ~/Fregata/media/
```

`rsync -aH` preserves timestamps, permissions, and hard links —
important for the recordings index, which uses inode numbers in
some places. Don't `cp -R` unless you're sure your shell is set
up for it.

For very large media folders (multi-TB), this copy can take
hours. Consider Path A if you want to be up and running faster.

### Either way: verify the layout

After moving, the destination should look like:

```
<config-dir>/
├── config.yml
├── frigate.db
├── frigate.db-shm        # may not exist; SQLite WAL-mode artifacts
├── frigate.db-wal        # same
├── model_cache/          # Frigate+ models, if any
└── ssl/                  # if you'd configured TLS

<media-dir>/
├── recordings/<camera>/<YYYY-MM-DD>/<HH>/<MM.SS>.mp4
├── clips/<camera>-<event>.mp4
└── exports/
```

Same paths Frigate-on-Linux uses. Nothing inside changes shape.

## Step 4: Adapt your `config.yml`

Open `config.yml` in your config dir. Most of it is already
correct for Fregata — the schema is identical. What you almost
certainly need to change:

### 4.1 Replace the detector (automatic)

On first launch, Fregata will substitute your existing detector in your `config.yml` with Fregata's custom CoreML detector written in Rust. It will create a backup of your existing `config.yml` first, so if you ever want to go back to Docker-based Frigate you easily can.

If you do not have a Frigate+ subscription, or are not using a custom model, the bundled YOLOv9-tiny 320x320 model will load by default. 
You don't need a top-level `model:` block unless you're switching to a custom model or do not have a Frigate+ subscription.

If you were running a custom ONNX model with `model.path`, the
path stays the same (point it at the file in your new config
dir if you moved data). The CoreML execution provider can
usually load any opset ≤17 ONNX export; older opsets work too.
If your model uses ops the ANE doesn't support, the runtime
falls back to the GPU automatically. See
[Detection tuning](/guides/detection-tuning/) for the full
detector reference.

If you were running TensorRT, EdgeTPU, OpenVINO, ROCm, Hailo,
RKNN, DeepStack, or any other Linux-only detector — see
[Things that don't migrate](#things-that-dont-migrate) below.

### 4.2 Drop Linux-only ffmpeg overrides

Look at any global or per-camera `ffmpeg:` blocks for
`hwaccel_args` or `input_args` that mention `vaapi`, `qsv`,
`cuda`, `nvenc`, `v4l2_m2m`, etc. Those are Linux acceleration
flags; on Fregata they'll fail.

Either delete them entirely (Fregata's defaults already use
`-hwaccel videotoolbox` for decode and `h264_videotoolbox`
for encode) or replace with `videotoolbox`:

```yaml
# OLD — Linux Docker
ffmpeg:
  hwaccel_args: preset-vaapi

# NEW — Fregata; usually you can just delete this, it's set by default
ffmpeg:
  hwaccel_args: preset-videotoolbox-h264
```

If you weren't overriding ffmpeg presets, skip this step.

### 4.3 Check absolute paths

Anything in `config.yml` that referenced `/config/...` or
`/media/...` was a Docker-internal path. Update to the host
path (or relative — Frigate resolves most paths against the
config dir).

The most common offender is `model.path`:

```yaml
# OLD — Docker-internal path
detectors:
  cpu1:
    type: cpu
  # ...
model:
  path: /config/yolonas.onnx

# NEW — relative to the config dir, or host-absolute
model:
  path: yolonas.onnx
  # or:
  # path: /Users/you/Fregata/config/yolonas.onnx
```

Other places to check: `tls.cert_path`, `mqtt.tls.ca_cert`,
anything ending in `_path` or `_file`.

### 4.4 Environment variable references

If your `config.yml` references env vars via the
`{FREGATA_MQTT_PASSWORD}` or similar tag, those need to be set in **Settings →
Environment Variables** in Fregata's tray menu. Docker's
`environment:` block doesn't carry over.

The most common case is the MQTT password:

```yaml
mqtt:
  enabled: true
  host: 10.0.1.42
  user: fregata
  password: {FREGATA_MQTT_PASSWORD}
```

In Fregata's tray, **Settings → Environment Variables…**, add a
row `FREGATA_MQTT_PASSWORD` with the value, and the next start
will pick it up.

### 4.5 Things you don't need to touch

The schema is otherwise identical between Frigate and Fregata.
**Cameras, motion masks, zones, object filters, recording rules,
event retention, snapshot config, MQTT, Home Assistant, GenAI,
semantic search, face recognition, LPR, audio events, birdseye,
review, notifications, auth** — all carry over verbatim.

For per-key details on anything in `config.yml`, see
[the Frigate config reference](https://docs.frigate.video/configuration/)
— Fregata follows that schema strictly.

## Step 5: First launch

Start Fregata from the tray or via the initial Welcome Dialog. Watch for:

- **Status reaches `Running`** within a few seconds. If it
  hangs in `Starting` or flips to `Error`, the most useful
  thing is **Settings → Open Frigate Logs** in the tray.
- **Detector inference time** in the tray (or the web UI's
  System tab) sits at **1–2 ms** on the ANE. 5–15 ms means
  the GPU; 50+ ms means CPU and something's off — see
  [Detection tuning](/guides/detection-tuning/#ane-vs-gpu--which-should-i-use).
- **Cameras populate** the live tile grid. They should appear
  within a few seconds of `Running`. If a camera shows
  "Stream not available", that's an upstream RTSP issue, not
  a Fregata problem — see [Troubleshooting](/guides/troubleshooting/#web-ui-loads-but-cameras-say-stream-not-available).
- **Recordings show up** in the **Recordings** tab. Frigate
  writes a few minutes of segments before they appear in the
  scrubber, so wait a moment.
- **Events flow** to the **Review** tab as soon as detections
  fire.

If config validation fails, Fregata writes the path-of-the-bad-key
to the log:

```
FATAL: cameras.driveway.detect.fps: input should be greater than 0
```

Fix in `config.yml`, then **Restart Frigate** from the tray.

## Step 6: Re-wire integrations

The wire format hasn't changed — same MQTT topics, same HTTP API,
same WebSocket events. What needs updating is *where to point*.

### Home Assistant

Update the Frigate HACS integration's URL to the Mac's IP or hostname
(**Settings → Devices & Services → Frigate → Configure**).

One change from Docker: Fregata serves **HTTPS with a self-signed
certificate** on `8971` by default. Point HA at
`https://<mac-ip-or-hostname>:8971` and **turn off "Validate SSL"** in
the integration's config so HA trusts the cert (or, for remote access,
front Fregata with a reverse proxy that has a real cert) — see the
[Home Assistant guide](/guides/home-assistant/#3-configure-the-integration).

The integration rediscovers cameras automatically. Existing
Lovelace cards, automations, and recorder data keep working.

### MQTT broker

If your broker was a separate container (Mosquitto, EMQX, etc.),
keep it running — Fregata talks to it the same way Frigate did.
Just update the `mqtt.host:` in your new `config.yml` if the
broker's IP / hostname changed when Docker came down.

If the broker was inside your `docker-compose.yml` and went away
with `docker compose down`, you have two options:

- **Move it to a Home Assistant Mosquitto add-on**, which is
  the easiest path if you're a HA user.
- **Run it natively on macOS** (`brew install mosquitto`
  + `brew services start mosquitto`).

### Reverse proxy

If you had Caddy / Traefik / nginx in front of Frigate's
`8971`, update the upstream from the Docker container's name
or IP to the Mac's `127.0.0.1:8971` (or LAN IP if the proxy
is on a different host). Note Fregata defaults to self-signed
HTTPS on `8971`; set `tls.enabled: false` so a plain-HTTP upstream
works, or point the upstream at `https` and skip its cert
verification.

See [Network & remote access](/guides/network-and-remote-access/#putting-fregata-behind-a-reverse-proxy)
for the rest of the macOS network story.

## Step 7: Wind down Docker

Once you've watched Fregata for a day or two and you're happy
with it:

```bash
# Drop the containers (already done, but the network is sticky)
docker compose down --volumes --remove-orphans

# Optional: remove the Frigate image to reclaim disk
docker rmi ghcr.io/blakeblackshear/frigate:stable

# Optional: uninstall Docker Desktop / OrbStack / Colima entirely
# if Frigate was the only thing keeping it around
```

The `--volumes` flag in the first command **deletes the Docker
volumes**. Skip it if you want to keep the old data around as a
rollback option.

## What carries over without changes

A short list to make the migration feel less scary:

- **`config.yml` schema** — every key Frigate understands works
  in Fregata.
- **Recordings format** — segmented MP4s, identical naming
  convention, same SQLite events database.
- **MQTT topic taxonomy** — `frigate/<camera>/<class>`,
  `frigate/events`, `frigate/stats`, all unchanged.
- **HTTP API** — same paths under `/api/`, same response
  shapes.
- **WebSocket events** for live event streaming.
- **Frigate+** — same account, same `plus://...` identifiers,
  cached models reused via the file at the same path.
- **The web UI** — same UI, same tabs, same scrubber.
- **Authentication, review, semantic search, face recognition,
  LPR, GenAI, audio events, birdseye, notifications, zones,
  masks** — same shape, same behavior.

## Things that don't migrate

Most of these are about Linux-only acceleration paths that
were the wrong choice on a Mac in the first place:

- **TensorRT models.** TensorRT engines are NVIDIA-specific
  binaries. Re-export your model to ONNX (most YOLO trainers
  ship `--include onnx`) and use it as a custom CoreML
  detector model. See
  [Detection tuning — Bringing your own model](/guides/detection-tuning/#bringing-your-own-model).
- **EdgeTPU detectors.** Coral USB / M.2 modules don't pass
  through to macOS cleanly, and the Apple Neural Engine is
  faster anyway. Switch to `coreml`.
- **OpenVINO / ROCm / Hailo / RKNN / DeepStack / DeGirum /
  Synaptics / Teflon** — Linux-NPU integrations, no analog on
  macOS.
- **`v4l2_m2m`, `vaapi`, `qsv`, `cuda` ffmpeg presets.** Drop
  them; Fregata's defaults already use VideoToolbox.
- **Docker-specific environment-variable plumbing.** Anything
  you set in `docker-compose.yml`'s `environment:` block needs
  to move to **Settings → Environment Variables** in Fregata.
- **`/dev/shm` mounts and tmpfs sizing knobs.** Fregata uses a
  RAM-disk under mounted automatically — see
  [Performance — RAM-disk cache](/guides/performance/#ram-disk-cache).

For a wider tour of what differs, see
[Fregata vs Frigate](/reference/fregata-vs-frigate/).

## Rolling back

If something doesn't work and you'd rather go back to Docker
while you debug:

1. **Quit Fregata.**
2. **Restart the Docker stack:**
   ```bash
   docker compose up -d
   ```
3. **Restore the Home Assistant URL** if you'd changed it.

Both setups read the same `config.yml`, so any changes you
made in step 4 still apply (Frigate will ignore the
`coreml` detector type and refuse to start until you flip it
back to `cpu` or whatever you were using before). If you want a clean rollback, restore your
old `config.yml` from a backup or revert the `detectors:`
block.

The Docker volumes are still there if you skipped the
`--volumes` flag in step 7 — just bring the stack back up and
your old recordings are untouched.

## Common gotchas

A short list of things people trip over:

- **"Detector inference time is 50+ ms"** after migrating —
  the `coreml` detector fell back to CPU. The first warmup
  inference logs which tier it landed on; check the crash
  log for the line that starts `coreml: warmup classified
  as`. See [Detection tuning](/guides/detection-tuning/#verifying-a-model-swap-worked).
- **"Cameras don't appear in HA after the migration"** — the
  HA integration still points at the Docker host. Update the
  URL per step 6.
- **"My recordings dropped to a few seconds"** — the
  per-camera retention rules pruned old segments because the
  database thinks the dates are wrong. Check that your
  `config.yml`'s `record.retain.days` matches what you had
  before; check your Mac's clock is set automatically.
- **"Fregata says 'Could not access the local network'"** —
  you skipped the welcome wizard's permission grant. **System
  Settings → Privacy & Security → Local Network**, enable
  Fregata.
- **"Web UI is unreachable from another device"** — macOS
  firewall. See
  [Troubleshooting — Web UI unreachable from another device on the LAN](/guides/troubleshooting/#web-ui-unreachable-from-another-device-on-the-lan).

Anything else, [Troubleshooting](/guides/troubleshooting/) is
indexed by the exact error string the app surfaces.