# Fregata vs Frigate

Fregata is built on the excellent open-source
[Frigate NVR](https://github.com/blakeblackshear/frigate). The
short pitch: **Frigate is the Python core; Fregata is a native
macOS shell around it that swaps in Apple-native acceleration**.

:::tip
If you're already running Frigate in Docker on a Mac and just
want the migration steps, skip ahead to
[Migrating from Frigate to Fregata](/getting-started/migrating-from-frigate/).
This page is the conceptual write-up; that one is the
soup-to-nuts walkthrough.
:::

## In one sentence

Fregata is Frigate plus an Apple-Neural-Engine detector, plus
VideoToolbox decode/encode, plus hundreds of macOS-specific performance optimizations and tweaks, bundled as a signed Mac app with all dependencies packaged in, with a $10 license.

## What Fregata adds

### A CoreML detector that runs on the ANE

Frigate detects on the CPU, an EdgeTPU, an NVIDIA GPU
(`tensorrt`), an Intel iGPU (`openvino`), or a couple of more
exotic accelerators. None of those help on Apple Silicon.

Fregata adds a `coreml` detector — a Rust dylib that owns ONNX
Runtime's CoreML execution provider, configured to prefer the ANE.
Bundled YOLOv9-tiny inference is in the 1–2 ms range per frame on
the Neural Engine, versus 40–80 ms on the CPU path.

The detector type and how to swap models (nearly any ONNX model, including Frigate+ models are supported) is documented at
[Detection tuning](/guides/detection-tuning/).

### VideoToolbox decode and encode by default

Frigate-on-Linux uses CPU ffmpeg by default and lets you opt into
hardware accel. Fregata-on-macOS flips that around: every input is
`-hwaccel videotoolbox`, recording defaults to
`h264_videotoolbox`, the RTSP re-stream uses
`h264_videotoolbox`. Hardware H.264 / HEVC decode and encode runs
on the dedicated media engine, leaving the CPU free.

You can override the presets exactly as on Linux Frigate; the
mechanism is identical. The defaults just match the platform.

### Bandwidth-adaptive transcoding for recordings and live view

Upstream Frigate serves recordings as fixed-quality MP4 segments — the player has no
quality ladder and can't adapt to a slow connection. On a weak LTE or 5G signal a 4K or
high-bitrate stream simply won't load.

Fregata adds an opt-in HLS adaptive bitrate layer that is **Fregata-exclusive and not
available in upstream Frigate**. When enabled, for recordings the web player automatically switches
between quality rungs (default: 1080p / 720p / 360p) based on measured throughput — no
manual quality selection, no buffering from overshooting available bandwidth. 360p at 600
kbps loads cleanly on even a poor cellular signal.

The top rung is always a passthrough copy (`-c:v copy`) for H.264 sources — free, no
encode cycles. Lower rungs are transcoded entirely on the Apple Silicon **dedicated Media
Engine** via VideoToolbox — **zero CPU**. Clients on the local network bypass the ladder
and receive the full-resolution source stream.

`live: true` also brings each rung into the live view stream dropdown allowing you to
manually switch qualities for live streams.

This feature is macOS-only and not in upstream Frigate. See [Adaptive
transcoding](/reference/adaptive-transcoding/) for the full configuration reference.

### A Swift menu-bar app and supervisor

Frigate ships as a Docker image. Fregata ships as a `.app` bundle:

- **Menu-bar tray** for live status, performance metrics, log access, the license
  screen, settings.
- **Supervisor** that launches the Python core and all the necessary processes, watches them,
  restarts on crash with exponential backoff, captures early
  stderr to a survivable place when something goes wrong before
  the log redirect kicks in.
- **Welcome wizard** for permission grants and folder choices.
- **Native Login Item** so Fregata can always start on boot.
- **Custom Update Checker** so you always know when new versions are available.

None of this is Frigate; it's the macOS-native experience layer.

### Licensing

Fregata is paid software ($10/year for the update window). The
licensing system is local-first — the activation token lives on disk, the Mac runs offline indefinitely while the app is
up (a 7-day window applies only to *restarting* with a stale
token), and an expired paid license just stops *new updates*.
Existing versions keep running forever.

The whole thing is described in [Activation](/getting-started/activation/)
and [Updates & renewals](/guides/updates-and-renewals/).

### Bundled binaries

Fregata's `.app` bundle ships its own ffmpeg, ffprobe, nginx, and
go2rtc, signed with our Developer ID. You don't install Homebrew,
don't `brew install ffmpeg`, don't manage a Python virtualenv. The
app is self-contained.

## What Fregata removes

The detectors and acceleration paths that don't apply on macOS:

- **EdgeTPU** — Coral USB / M.2 module. Not what Apple Silicon
  users would buy.
- **TensorRT** — NVIDIA GPU acceleration. Macs don't have NVIDIA
  GPUs.
- **OpenVINO** — Intel iGPU / NPU. Not on Apple Silicon.
- **ROCm** — AMD GPU. Not on Apple Silicon.
- **Hailo-8L** / **RKNN** / **Synaptics** / **Teflon** — Linux-
  only NPU integrations.
- **DeepStack / DeGirum / ZMQ-IPC detectors** — external inference
  servers, not the macOS-native shape.

If you need any of those, you want Frigate-on-Linux, not
Fregata-on-macOS.

## What stays the same

A non-trivial chunk of Frigate is identical:

- **The web UI** — same React app, same tabs, same recording
  scrubber. We've made several performance improvements and added
  the adaptive transcoding player for recordings and live view.
- **`config.yml` schema** — every key Frigate understands works in
  Fregata, with the exception of the removed detector types.
- **MQTT topics, HTTP API, WebSocket events** — the wire surface
  Home Assistant and other integrations target is identical.
- **The Frigate+ workflow** — your account, your training data,
  your trained models. Fregata reads them via the same
  `plus://...` identifier.
- **Recordings format** — segmented MP4s, same naming convention,
  same SQLite events table. You can `rsync` recordings between a
  Frigate-on-Linux install and a Fregata-on-macOS install and the
  web UI will show them.

## Where to read which docs

When the docs cover **macOS-specific** ground — the menu-bar app,
licensing, the CoreML detector, VideoToolbox presets, system
requirements, supported Mac models, the Welcome wizard — read
**Fregata's docs** (you're here).

When the docs cover **the upstream Frigate engine** — every
non-detector config key, MQTT topic taxonomy, HTTP API, zone
geometry, GenAI integration, semantic search, face recognition,
LPR, PTZ tracking — read **[the Frigate docs](https://docs.frigate.video/)**.
We don't mirror them, the upstream Frigate docs are excellent and are always up to date.

This page is the only one that tries to keep both halves fresh —
if Frigate adds a detector type and we add support, the
"What Fregata removes" list shortens.

:::note
We send patches upstream for things that aren't macOS-specific,
too. The relationship is meant to be additive, not a fork that
drifts.
:::