[ Home Automation — Links & Resources ]

External tools, libraries, and references that pair with the
configs, automations, and guides on the
Home Automation parent page.
Grouped by role in the stack:

  Platform & tooling   Home Assistant core, ESPHome, the HACS
                          store, Node-RED — the "OS layer" everything
                          else plugs into.
  Protocols            Zigbee, Z-Wave, Matter / Thread, MQTT.
                          Pick the protocol of your radio, not the
                          other way around.
  Voice / TTS / STT    Self-hosted text-to-speech and speech-
                          to-text pipelines via the Wyoming protocol --
                          Piper, faster-whisper, openWakeWord.
  Cameras & NVR       Frigate, Scrypted, go2rtc, ONVIF.
                          Object detection + RTSP wrangling so HA can
                          react to motion + faces instead of polling.
  Hardware             ESP32 / ESP8266, Raspberry Pi, Sonoff,
                          Shelly, Aqara, and the gateway / coordinator
                          modules each protocol layer needs.
  Community & docs    Where to actually find answers when a
                          blueprint silently won't trigger at 2am.

Open-source home automation platform. Runs on a Raspberry Pi, x86 mini
PC, ProxMox VM, or anywhere a container will. Local-first by design:
the database, the automations, the dashboards, all on your hardware.
Cloud integrations exist but are optional.

The supervised installer (HA OS) is the easiest entry point; HA
Container is what you want for an existing docker setup. All
automations on this site assume a working HA install with the standard
integrations enabled (companion app, ONVIF, MQTT). Each guide calls
out its specific dependencies up front.

Docs: home-assistant.io/docs

Firmware framework for ESP32 / ESP8266 / RP2040 microcontrollers that
generates a HA-compatible device from a small YAML config. Web flash
from Chrome via
web.esphome.io;
HA auto-discovers and adopts the device the moment it appears on the
network.

The fastest way to turn a $5 board into a temperature sensor, BLE
proxy, sprinkler controller, garage-door relay, or anything else with
a GPIO pin. Covered hands-on in the
ESP32 Bluetooth Proxy guide
on the parent page.

Community add-on store for custom integrations, themes, and
Lovelace cards that aren't shipped with HA core. Install via the docs;
adds a "HACS" section to the HA sidebar from which you browse and
install community plugins with one click.

Required for many of the niche integrations: third-party device
support, advanced dashboard cards (mini-graph, button-card, mushroom),
blueprint repositories. Updates pulled from GitHub so each plugin is
auditable before you install.

Flow-based visual programming for IoT. Pairs with HA via the official
Node-RED Companion integration. Useful when your automation logic
gets gnarly enough that YAML state machines become hard to read --
drag-and-drop nodes for branching, looping, time gates, parallel
fan-out.

Not required for anything on this site (every automation here is plain
HA YAML), but a useful escape hatch when an automation grows past
20 lines of `trigger:` / `condition:` / `action:` blocks.

Home Assistant alternatives. openHAB is the Java-based one with a
strong rules engine; Domoticz is lighter-weight C++. Both are
self-hosted, both are open source, both have active communities.

Listed for completeness — the guides on this site target Home
Assistant specifically. Most of the YAML patterns translate to
openHAB rules / Domoticz Lua with minor syntactic adjustment; the
underlying state-machine concepts are platform-agnostic.

Bridge that lets you use Zigbee devices (sensors, switches, bulbs,
locks) without the vendor's proprietary hub. Talks to a coordinator
USB stick (Sonoff ZBDongle-E, Conbee II, etc.), exposes devices via
MQTT, which HA's MQTT integration then auto-discovers as native
entities.

Vendor-agnostic device support is the killer feature -- Aqara,
Sonoff, IKEA, Philips Hue (without the bridge), Tuya, Develco, etc.
The supported devices list
is the first thing to check before buying any Zigbee hardware.

Z-Wave equivalent of Zigbee2MQTT — bridge between a Z-Wave
coordinator stick (Aeotec Z-Stick 7, Zooz ZST10, etc.) and Home
Assistant. Same model: pair devices once, HA sees them as native
entities, automations work without thinking about the underlying
protocol.

Z-Wave is the slower, lower-bandwidth, longer-range cousin of Zigbee.
Door / window sensors and battery-powered devices that report once
an hour are its sweet spot; high-frequency sensors (presence, motion
on a busy hallway) are better on Zigbee.

The "make-everything-work-with-everything" smart-home standard that's
been simmering since 2019. Matter is the application layer; Thread is
the IPv6 mesh network underneath (think WiFi-class throughput at
Zigbee-class battery life).

HA has first-class Matter support and can run as a Matter controller
directly. Adoption is still uneven — many devices ship with
Matter alongside their vendor cloud, not instead of it — but for
new purchases, "Matter over Thread" is increasingly the right default
when the device offers it.

The de-facto MQTT broker for self-hosted setups. Lightweight, mature,
runs in a few MB of RAM. HA has a built-in MQTT integration that
either connects to an external Mosquitto or runs one as an add-on
(simplest path).

Required for Zigbee2MQTT (the M stands for MQTT), useful for any
custom DIY device or ESP32 sketch that wants to publish state to HA
without writing a custom integration. Add a username/password and
keep the broker firewalled to your LAN; never expose 1883/tcp to
the internet.

Fast neural text-to-speech that runs on a Raspberry Pi 4 in real
time. Drop-in replacement for HA's cloud TTS engines (Google,
Amazon Polly) when you want local-only voice output: alarm
announcements, doorbell callouts, anything triggered from automations.

Plugged into HA via the Wyoming protocol -- HA ships a Wyoming-Piper
add-on that handles install, model download, and voice selection
in two clicks. Used by the DIY alarm
system guide for the entry-warning + alarm-fired announcements.

Speech-to-text via OpenAI's Whisper model, optimized with CTranslate2
for ~4x speedup over the reference implementation. Lets HA do offline
voice commands without round-tripping audio to Google / Apple / Amazon.

Same Wyoming protocol pattern as Piper -- Wyoming-faster-whisper
add-on handles install. Pair with
openWakeWord
for the "Hey Jarvis / Hey Mycroft" wake-word detection step, and
you have a fully local voice pipeline that never leaves your network.

First-party voice-satellite hardware from the HA team. Small puck-
shaped device with mic + speaker that runs the Wyoming protocol
locally and talks to your HA install for everything else. Cheaper
and more private than an Echo / Google Home, and the wake-word /
TTS pipeline is all self-hosted.

Open hardware design, KiCad files published. Useful as a known-good
voice satellite when you want to test the Piper + faster-whisper
stack without first building one out of an ESP32S3-Box.

Self-hosted NVR with realtime AI object detection. Designed to run
alongside HA on the same hardware (or as a HA add-on); inference
runs on a Coral USB / PCIe accelerator, Intel iGPU via OpenVINO, or
CPU as a fallback.

The killer feature is reliable "person / car / package / dog at the
door" event triggers that don't drown HA in motion-detection noise.
Records continuous + event clips, exposes everything via MQTT for
automations. Cameras must speak RTSP -- almost all do, even the
cheap ones.

Multi-platform camera / smart-home bridge that focuses on HomeKit
Secure Video integration without forcing you to buy into Apple's
ecosystem at the camera layer. Also bridges to HA, Alexa, Google
Home, MQTT.

Useful when you have a mix of camera brands (Reolink, Hikvision,
Amcrest, Unifi) and want a single normalisation layer that gives
each one a consistent stream + metadata format before HA / Frigate
see it.

Ultra-low-latency RTSP / WebRTC streaming server. The piece that
makes camera streams actually playable in HA dashboards without 4-8
second buffering. Frigate bundles go2rtc internally; HA's "Camera"
integration uses it under the hood for WebRTC.

If your HA camera streams look chunky or have 5+ seconds of latency,
you almost certainly want go2rtc in front of them. Standalone install
or as a HA add-on.

Open standards for IP camera control: PTZ moves, presets, snapshot
URLs, event streams. HA's ONVIF integration uses this for the
pattern of "trip a sensor → PTZ camera moves to the zone preset
→ snapshot → push notification with image attached" that
the DIY alarm guide documents.

Most non-cheap brand-name cameras (Reolink, Amcrest, Hikvision, Dahua,
Foscam, Axis) implement ONVIF. The really cheap Tuya / Wyze / Ring
ones usually don't. ONVIF support is the second thing to check when
buying a camera, right after RTSP.

$3-15 microcontrollers with WiFi + Bluetooth, the default DIY-sensor
platform. Pair with ESPHome (above) for HA integration with zero
custom firmware development.

Useful sub-flavors:
  - ESP32-C3 Mini   smallest, cheapest, single-core RISC-V
  - ESP32-S3        dual-core, USB-OTG, lots of GPIO
  - ESP32-S3-BOX-3  pre-assembled voice satellite kit
  - M5Stack Atom Lite   tiny BLE proxy in a cube
  - ESP8266 (NodeMCU)  legacy, cheaper, single-core, no BLE

Reasonable default HA host hardware: Pi 4 (4GB or 8GB) or Pi 5
running HA OS off a USB SSD (not SD card — the database write
load chews through them in a year). Coral USB AI accelerator slots
into a free USB-A port for Frigate inference.

For larger installs (50+ devices, Frigate with 4+ cameras at 4K),
graduate to a small x86 mini-PC (Beelink, Intel NUC, ASUS PN-series).
The platform port is one-click via the HA OS installer.

The three vendor lines most worth knowing for inline devices:

  Sonoff   cheap WiFi / Zigbee smart switches, plugs, and the
            ZBDongle-E Zigbee coordinator. The basic 1-gang relay is
            $5; flash with ESPHome if you want fully local control.
            Sonoff's Zigbee gear works with Zigbee2MQTT without
            their proprietary eWeLink app.
  Shelly   compact in-wall WiFi relays (Shelly 1, Shelly Plus 2PM,
            Shelly EM3 for whole-house energy monitoring). Best
            quality of the cheap options; local HTTP/MQTT API, no
            cloud needed.
  Aqara    Zigbee sensors (motion, contact, vibration, leak)
            with multi-year battery life. Door / window sensors are
            $10-15 and last 2-3 years on a CR1632. Pair via
            Zigbee2MQTT and ignore their gateway.

Coordinator / controller sticks. Plug one of these into the Pi's USB
port, pair with USB extension cable (the USB 3.0 ports throw RF
interference that kills 2.4 GHz Zigbee range -- use a 1m extension
to a USB 2.0 port instead).

  ZBDongle-E    Silicon Labs EFR32MG21 Zigbee coordinator,
                 ~$18, works with Zigbee2MQTT out of the box.
                 Range covers most small/medium houses without a
                 Zigbee router.
  Aeotec Z-Stick 7  Z-Wave 700-series stick, ~$50,
                 works with Z-Wave JS UI. Required if you've
                 already invested in Z-Wave devices (older homes,
                 inherited installations).

The official docs. Comprehensive, frequently updated, and the first
place to look when an integration / automation isn't doing what you
expect.

Most useful sub-sections:
  - Automations
  - Scripts (script syntax is shared with automation actions)
  - Blueprints (parameterised automations)
  - Template integration (custom sensors from any data)

Active forum where most "why doesn't my YAML do X" questions have
already been asked and answered. Searches usually surface a working
example in the first page of results.

The Blueprints Exchange sub-forum is particularly useful: free,
community-contributed blueprints for common patterns (door-lock
auto-arm, low-battery aggregation, presence-based heating). Many
of the snippets on the parent page started life as ideas borrowed
from there.

Faster than the forum for "is this hardware any good" / "what
integration handles brand X" / show-and-tell screenshots of
people's dashboards. Less useful for deep debugging, more useful
for "what should I buy / install" decisions.

Official blog. Monthly release notes are the canonical "what
changed and what's about to break" reference -- worth reading
before every HA upgrade so deprecated entity IDs don't catch you by
surprise. New-feature announcements drop here first.