HAIR

Español · Français · 日本語 · Deutsch · Polski · Português · Nederlands · Italiano · Русский

HAIR

HAIR turns IR remotes into native Home Assistant entities. Point any remote at an IR receiver and press a button, and HAIR gives you back a device, a button, and an event you can automate. No vendor cloud, no YAML, nothing learned into somebody else’s box.

Install

HACS (recommended)

Click the button above, then Download, then restart Home Assistant.

Or find it by hand:

1. Open HACS in your Home Assistant sidebar.
2. Search for HAIR.
3. Click it, then Download.
4. Restart Home Assistant.

Manual

1. Copy custom_components/hair into your HA custom_components/ directory.
2. Restart Home Assistant.

Add the integration

1. Go to Settings > Devices & Services.
2. Click Add Integration and search for “HAIR”.
3. The config flow auto-detects your IR emitters and receivers.
4. Find HAIR in the sidebar.

Requirements

• Home Assistant 2026.6 or later.
• To capture (RX): an integration exposing HA’s native InfraredReceiverEntity or, for radio remotes, a receiver on the radio_frequency platform (Home Assistant 2026.11 and later). ESPHome IR receivers work day one; SMLIGHT Ultima receivers work natively since HA 2026.7; MQTT IR hubs work since HA 2026.8, though most only listen inside a short learn-mode window that has to be re-armed; a Broadlink listens with BroadSniff installed beside it (see The receiver row); any other adopter works automatically.
• To send (TX): at least one integration on HA’s native infrared platform, such as ESPHome, Tuya Local, Broadlink, SMLIGHT, or MQTT.

These integrations have adopted the infrared platform:

Home Assistant 2026.11 adds a radio_frequency platform for 433 MHz and other radio remotes, and HAIR hears every receiver on it. On 2026.11 that is a Broadlink RM pro or RM4 pro with BroadSniff 0.3.0. ESPHome radio receivers follow with Home Assistant 2026.12 and the matching ESPHome release. See Radio remotes.

Pluck reads codes an integration has already stored in Home Assistant. For Broadlink that means codes learned with remote.learn_command: a blaster you have only ever transmitted through has nothing to pluck yet, and codes learned in the Broadlink phone app stay in Broadlink’s cloud and never reach Home Assistant. This applies to every RM model Home Assistant supports, not only the newer ones.

Coming from OpenIRBlaster? The Plucker reads the code library it learned, with the carrier it measured for each code, so you do not have to learn your remotes again. From OpenIRBlaster 1.3.2 the library stays in Home Assistant after the integration is removed. On 1.3.1 and earlier, removing it deletes the library, so pluck first.

As more integrations adopt the infrared platform, HAIR picks them up automatically.

Quick start

To go from a fresh install to a working button:

1. Point your remote at the IR receiver and press a button. HAIR shows it live on the Sniffer tab.
2. Hover over the remote’s name and click it to rename it (optional).
3. Click USE, then Make a Device. HAIR creates a device with a button entity for every signal you captured.
4. Open the device and press one of its buttons. Home Assistant sends the code through your emitter.

Capture a remote

The Sniffer is a live listener. It shows every signal your receivers hear, groups signals by the remote they came from, and filters out repeat frames from a held-down button. A new remote needs at least three presses before HAIR trusts it enough to show it as its own card, so give it a few before you go looking for it.

To capture a remote:

1. Open the Sniffer tab.
2. Point the remote at your receiver and press buttons. Each source remote appears as a card, expandable to show its individual signals with an S/L diamond fingerprint.
3. Click a signal’s diamond pattern to give it an alias, so you can tell buttons apart before you assign them.
4. Click Test on a signal to fire it through an emitter and confirm it works.
5. Click a signal to assign it to a device, or USE the whole remote to make a new Device or Remote.

When you assign a signal, pick a name from the device-type template list (Power On, Volume Up, Mode: Cool) or type your own, and set a Send Times count if the device needs a command repeated to register; you can change this later in the editor. For an AC device, naming commands “Temp 22” or “Temp 24” wires them straight into the climate card’s thermostat control, stepped to whatever temperatures you name. Assigning copies the signal into the device rather than removing it from the Sniffer, so you can assign the same signal to several devices or commands; an assigned row keeps flashing when you press its button, so you can tell the remote is still alive. Drag the grip handle on a remote, or on a signal row, to reorder them; the order sticks.

A remote that leaks in from outside (a neighbor’s clicker, for example) can be hidden with the eye at the bottom-right corner of its row. Bring it back by turning on the hidden glyph at the right of the receiver row. A hidden remote wears a small “hidden” badge, and the open eye restores it. The hidden glyph glows each time a hidden remote is heard. The X at the top-right corner of a row deletes the remote, and the trash can on a signal row deletes that one signal; both controls stay faint until you hover the row. Anything a receiver hears again comes right back after a delete, so hiding is the tool for keeping a remote out of the way for good. A remote already used to make a Device or Remote shows a count dot on USE; click it to jump to what you made, or use it again for a second room.

The receiver row

The receiver row at the top of the Sniffer has one pill per receiver, infrared and radio. A pill’s IR or RF badge names the medium. A solid badge means the receiver is taking new codes right now; a light one means it is not. A pill glows each time HAIR takes a code from its receiver. An always-on infrared receiver is always solid, with nothing to press.

Some receivers hear codes only while a capture window is open, such as a hub in learn mode. Any integration can say its receiver works this way with a capturing attribute on the receiver entity, and HAIR then opens and closes the window for you; the contract for integration authors is in Windowed receivers. Press the pill to open a window. It turns green and drains until the window ends. The pickers on the pill set the next window’s length and type and, on a radio receiver, its carrier. The Listen in the code editor and in the Fix window opens the window for the listen and closes it after.

The worked example is a Broadlink RM. Home Assistant’s Broadlink integration only sends, and BroadSniff gives the same RM a receiver that is a capture device: infrared, and on an RM pro or RM4 pro, radio too. Install it from HACS and add it against your Broadlink, and HAIR picks the receivers up on its own, with nothing to configure.

Radio remotes

From Home Assistant 2026.11, HAIR hears radio remotes too: keyfobs, ceiling fan remotes, plug handsets and doorbells, on 433 MHz and the other common bands. Radio codes appear in the Sniffer beside infrared ones, with a radio glyph and their band, and they assign, alias and trigger the same way. On 2026.11 the receiver is a Broadlink RM pro or RM4 pro with BroadSniff; ESPHome radio receivers follow with 2026.12. An always-on radio receiver files new codes only while its pill’s capture window is open, so a neighbor’s doorbell does not fill the Sniffer, and it hears codes HAIR already knows all the time. Rolling-code remotes such as car keys send a different code on every press, so HAIR cannot recognize their buttons. Radio remotes has the details.

Turn signals into a device

Any captured, pasted, or plucked set of codes can become a Device, something HAIR sends codes to, or a Remote, a handset HAIR recognizes and fires triggers from.

To turn a set of codes into a Device or Remote:

1. Find the set of codes: a remote in the Sniffer (see Capture a remote), a pasted remote in the Clipper, a pulled remote in the Plucker, or a wig in the Closet (see Import codes).
2. Click USE.
3. Choose Make a Device or Make a Remote, name it, and pick hardware – emitters for a Device, receivers for a Remote.
4. Click Create.

The Clipper is for pasting a code by hand (Pronto, a Tuya or Broadlink base64 code, a Global Cache sendir code, or a Tasmota code); the Plucker pulls codes another integration has already learned, such as Broadlink, Tuya Local or OpenIRBlaster, without transmitting anything over the air (see Pluck codes you already learned).

For a Device, open it afterward and click ACTIONS on a command to map it to an entity action, such as turn_on or volume_up; only mapped actions show up as controls, so an entity never claims a feature your remote does not have. The entity follows every send HAIR makes to the Device through those mapped actions, whether it came from the entity, a HAIR button, remote.send_command, the panel or a pinned Remote.

You can also click the dashed tile at the end of the grid to start one from scratch, or drop a code file onto it so HAIR opens the add dialog already filled in; dropping does not create anything by itself, and completing the dialog files the codes as a wig in your Closet at the same time it creates the Device or Remote. To duplicate a Device instead, use its card; commands and emitter assignments come with it, so you only rename the clone.

Each Remote you make is its own device in Home Assistant, so its triggers show up by name under Device in the automation editor; click its header’s Home Assistant glyph to jump there. Each Remote also has a Last pressed event entity whose event types are its buttons, for one automation that reacts to whichever button was pressed.

A Remote can also keep its own state. Give it a Type under its name (media player, fan, light, switch or screen) and map its buttons with ACTIONS, as on a Device, and the Remote gets an entity of that type, named as the remote. There are then two kinds of state, and HAIR never syncs them: the Device is the TV as HAIR believes it is, from what HAIR sends it, while the Remote is what its handset last did. Pressing Power on the handset turns the Remote’s entity on; turning the Device on from Home Assistant leaves the Remote’s entity where it was. Picking a type maps the buttons for you if none are mapped yet, from the Device the Remote is pinned to or by the buttons’ names, and the panel says what it will do first. The Remote’s controls change only its own state and never send IR, so you can correct it when it drifts. Automate against, or expose to a voice assistant, whichever fits.

A Device can also build you a matching Remote, and a Remote a matching Device: open the gear, click Make a Remote or Make a Device, and name it. HAIR then asks whether to pin the two together; see Set up triggers.

Set up an air conditioner

An AC remote does not send single buttons, it sends whole states: every press carries the complete mode, fan, swing, and temperature the unit should switch to. HAIR handles that as a climate entity driven by a full state matrix instead of a list of commands.

To set one up:

1. Drop a SmartIR climate JSON file onto the Closet (or find one already there).
2. Click USE, then Make a Device.
3. HAIR creates a fully-controlled climate entity. Change the temperature or mode on the thermostat card, and HAIR looks up and sends the matching code.

Swing and temperature controls appear only when the file’s matrix actually has those dimensions. The device’s detail page grows a STATE MATRIX card where you can browse the lattice one branch at a time, see which state was last transmitted, send any state directly, or press + Command to save one you use often as a one-tap command. A Power row sits at the top of the card: an Off chip always, an On chip when the file carries a separate wake code, and either one sends or saves as a command the same way a cell does. Temperatures display in your install’s unit while the file’s native numbers stay untouched underneath; climate files are read as Celsius unless they say otherwise. To prove the matrix works on your hardware, run Fit This Wig (see Fit a wig); the checklist covers 12 to 20 rows for the modes, fan speeds, swing positions, and temperature extremes instead of every cell.

Every command row on an AC Device also has a star; click it to make that command a thermostat preset in Home Assistant, named after the command, click again to remove it. This works for learned commands and for states saved from the STATE MATRIX card with + Command. Presets are local to the device and do not travel with a wig.

Listen to the wall remote. An air-conditioner handset can also be a Remote: it shows the same STATE MATRIX card, but for listening, with a LAST HEARD row naming the last state, when, and which receiver heard it. Browse to a state and click + Trigger to fire on exactly that state, or use the Remote’s “State heard” trigger to fire on any state with mode, fan, swing, and temperature as data. Pin it to a Device (see Set up triggers) and every state it sends gets re-sent there, so Home Assistant and the wall remote never disagree.

A few limits to know: files whose codes are stored as Xiaomi-controller Raw are refused on import, since that format is proprietary rather than timing data HAIR can convert. Of the cells that do convert, a small share (roughly half a percent) fail and are skipped, with the reason written into the wig’s notes; HAIR never invents a code for a state the file does not carry.

If the comb flags a cell, it stays in the matrix and shows up under Needs attention on the device. See Fix codes that need attention.

Pluck codes you already learned

If you taught your remotes to another integration, the Plucker copies those codes into HAIR without sending anything over the air.

1. Open the Plucker tab and click + Add Blaster.
2. Every code store HAIR finds in Home Assistant gets its own card, Broadlink first. Click a card to pluck it. Clicking it again later is safe: codes already plucked are not added twice.
3. The codes land as cards on the Plucker tab. Click USE to make a Device or Remote from them (see Turn signals into a device).

What the Plucker reads:

• Broadlink: codes learned with remote.learn_command, which the integration keeps in Home Assistant’s storage. Codes learned in the Broadlink phone app stay in Broadlink’s cloud and cannot be plucked. RF codes in the same store are set aside, since HAIR works with infrared.
• Tuya Local: the codes your Tuya hub captured, or one code at a time by replaying it into a silent listener (the last card in the dialog).
• OpenIRBlaster: the code library it learned, with the carrier it measured for each code.

Import codes (SmartIR and the closet)

Codes another integration has already learned, such as Broadlink’s, do not need a file: pluck them instead (see Pluck codes you already learned).

The Closet is where portable code sets, called wigs, live. Two kinds of entries hang there: codebooks installed with Home Assistant’s core infrared code library, and your own wig files, organized by brand. Search covers brand, name, and product identifiers like UPC, FCC ID, or ASIN, so a barcode typed off the box finds its wig. The Closet also converts several outside formats the moment you drop them in.

To import a file:

1. Open the Closet tab.
2. Drag a file onto the tab, or click Browse. HAIR reads it, converts it if needed, and shows a receipt naming the brand it filed under.
3. If the codes are already in your closet, the receipt turns yellow and lists every place they already hang. If the file supersedes a wig you already have, HAIR offers to replace the old one instead of filing a duplicate.
4. Click USE to make a Device or Remote from the entry, or CLIP to test it on the Clipper first.

These formats convert on drop: wig files (.wig.json, filed as-is), SmartIR JSON (media player, fan, and climate, in all four SmartIR encodings), Flipper Zero .ir files, LIRC lircd.conf files, and Girr exports, plus:

• Logitech Harmony device files and code sets.
• Global Cache code sets from Control Tower: the code-set CSV or the single-code email (a single sendir code also pastes straight into the code box).
• Tasmota IR codes kept as text: IRsend commands and IrReceived console lines, one per line with an optional name in front (a single one also pastes into the code box).
• irdb CSV files, where each row names a protocol and its device, subdevice and function, and HAIR builds the code. Rows in a protocol HAIR cannot build yet are listed in the wig’s notes.

Anything a conversion has to skip is written into the wig’s notes with a reason, so a partial import is never silent.

You can also skip these steps: drop a code file straight onto the dashed add tile on the Devices tab (see Turn signals into a device), and HAIR files it as a wig in your Closet and creates the Device or Remote in the same step.

Good to know: a Remote made from a wig, or a Device adopted from one, recognizes its own handset’s presses even though HAIR never learned those codes through a receiver.

Every arrival is also combed on the way in. Combing is a different question from fitting: a fitting asks whether a code works on your hardware, combing asks whether a wig’s codes agree with each other, and it can answer that on its own, without hardware or a protocol decoder. It catches things like a cell that quietly sends its neighbor’s code, a frame too short for the device to register, or a gap in an otherwise complete temperature run. The comb glyph on a closet row stays plain grey until something is checked, glows yellow when a finding needs a look, and glows red for the one class worth interrupting you for: the neighbor’s-code mix-up, since the device answers and looks like it worked while quietly setting the wrong state.

Fix codes that need attention

When the comb finds a problem in a wig, the device made from it shows a Needs attention block above its commands. Each row is one code and a reason.

To fix a code:

1. Click Fix on the card.
2. Do what the card asks. Some fixes are ready to accept. Some need a press from your remote, or a corrected code you paste in. Some ask you to pick between two buttons that share a name.
3. The row goes away. The device sends the fixed code from then on.

A code still sends as-is until you fix it, so nothing here stops you from using the device.

Share a wig

To share a device you have built:

1. Open the device’s detail view.
2. Click Save to Closet.
3. Pick a route: Save as New files a fresh wig and leaves the original alone. Update Closet Wig brings the shared file up to date with your device, and warns you first if the update would retire someone else’s fitting. Fit This Wig records which commands you have proved on real hardware, see Fit a wig below.

Fit This Wig only appears on a device that came from a wig in the first place. A device built from scratch just sees Save.

Fit a wig

A wig in your closet is a saved set of codes. A fitting is proof those codes actually work, and the proof travels with the file from then on. There are two names for what comes out: a wig, which is any shared code set, and a Perfect Fit, which is a wig one person proved every row of in one sitting. A wig nobody has finished proving is the ordinary case for a shared remote, not a broken one.

To fit a wig:

1. Adopt the wig onto a device and use it normally until you trust it.
2. Open the device, click Save to Closet, and choose Fit This Wig.
3. Hit TEST on each row of the checklist. HAIR reports SENT, or SENT and HEARD if a receiver caught the transmission. The checklist covers every lattice the wig carries, so a wig with presets lists each preset’s rows under its own name.
4. Check the rows you have proved. Check some of them and the button reads Save Fitting: your claims go on the file, and the closet lists the fitting with how far it got. Check all of them and it reads Save Perfect Fit. Check none and it is a plain Save, with no claims attached. On a state-matrix checklist, a dimension your unit genuinely does not have can be marked “not on my device” or “could not make it work” instead of checked. Three people excluding the same dimension tells you something real is going on.
5. If your device has gained or dropped commands since the wig was last saved, review the Changes with new fitting section before you sign.
6. Sign. Your verdicts tie to a key generated on your own install, not the name you type, so nobody can edit your results or fit in your name. Fitting the same wig again later just replaces your old signature.

A Perfect Fit is one person’s work. If somebody else proved half the wig before you, your checklist still starts empty: the green tick says one person found the whole thing working on their own hardware, and two half-fittings do not add up to that. The closet still counts what everybody proved between them, because that is worth knowing on its own.

Fix flagged codes under Needs attention before you fit. A fitting waits until that block is empty, because a claim about codes nobody has answered the doubts on is not a claim worth signing. To fix a code the comb did not catch, open the command, paste in a corrected code or press LISTEN, then save. A repaired wig is a different wig, so any change starts a brand new fitting with only your signature on it.

Give the device a beat between presses so you can watch it react before marking a row. Fittings are what make a shared wig trustworthy, and only perfect-fit wigs can graduate into generated Home Assistant integrations.

Set up triggers

Any IR signal can fire a Home Assistant automation as a native event entity.

To create a trigger:

1. Click the trigger button on a signal row, and pick which Remote it belongs to – HAIR Triggers by default, or + New Remote to make one on the spot. There are four places to find a signal to trigger from: a command on a device, a signal in the Sniffer, a signal in the Clipper, or a recorded send in the Mirror.
2. Set min hits (1 to 10) if you want to require more than one press before the trigger fires. This filters out stray or accidental presses.
3. Save. HAIR creates an event entity (for example event.hair_triggers_tv_power) under a shared “HAIR Triggers” device.
4. Use that entity as a trigger condition in HA’s automation editor. Its card flashes amber in the panel whenever it fires.

Only HAIR Triggers lets you pick a receiver; a named Remote’s triggers follow whichever receivers it already uses, and cannot move to another Remote later.

A trigger created from a Sniffer or Clipper row reacts to a raw signal without needing it assigned to a device first. A trigger created from a Mirror row only fires on signals arriving from outside Home Assistant; the house’s own sends never fire it, so an automation cannot trigger on its own output.

Pin a Remote to a Device and pressing the handset sends the matching command through that Device’s emitters; HAIR matches the button to the command on its own. Open the PIN row on the Remote’s header, or PINNED on the Device’s, and tick the other side; untick to unpin. One Remote can drive several Devices, and one Device several Remotes. HAIR never re-fires its own sends, so a pinned handset by the receiver will not loop, and a runaway pairing gets cut for a minute and logged without breaking the handset’s triggers.

Use the Mirror

The Mirror logs every IR command Home Assistant sends, at the moment it is sent, and whether a receiver heard it land.

To use it:

1. Send a command from a device, a Test button, an automation, or another integration on the infrared platform.
2. Open the Mirror tab and find the row.
3. Check the heard-back column. “Not heard” is neutral, not an alarm, since many setups are transmit-only, but it is how you spot a dead IR LED, a misaimed emitter, or an offline device without pointing a phone camera at anything.
4. Use the Search box, the Not heard pill, or the Emitter dropdown to narrow the list to one emitter.
5. Click Assign on a row to turn a command another app sent into a HAIR command, or Trigger to turn it into an automation trigger.

Repeat sends of the same command bump one row’s count instead of piling up. Deleting a row just clears the entry; it comes back the next time that signal is sent. The Mirror is also the third road for importing codes, next to the Clipper (paste) and the Plucker (pull by name): press a button in any vendor app whose blaster transmits through the infrared platform, and if a receiver hears it, the code appears in the Mirror ready to assign.

The Candy Drawer button at the top right of the Mirror opens a live, raw console of everything your receivers hear and everything HAIR sends, in a window of its own beside Home Assistant (or a dialog over the panel in the companion app, on a phone, or when pop-ups are blocked), one block per frame with its decode, Pronto and raw timings; nothing in it is saved, and Copy all gives you the text to paste into an issue.

Everything else

How it works

HAIR does not talk to hardware directly. It sits on HA’s native infrared platform for both capture and send, so any integration that adopts the platform works with HAIR automatically, and signals are matched with S/L pulse-duration fingerprinting rather than per-protocol decoding.

The Devices tab

The tab splits into two sections. DEVICES holds the things HAIR sends codes to: HAIR Devices (your managed profiles; drag to reorder, duplicate or delete from the corners of the card), Emitters and Receivers (your IR hardware, each showing a TX or RX badge, with -NATIVE or -BRIDGE marking which path a receiver is using), Proxies (hardware with both TX and RX on one board), and Blasters (pluckable vendor blasters, shown only when one is configured). REMOTES holds the handsets HAIR recognizes; HAIR Triggers, the built-in catch-all, is the first card there, and a Remote card shows how many of its triggers are on and off. Emitters and receivers show their health: every chip that picks them carries a dot, green when Home Assistant can reach the hardware and a hollow ember ring when it cannot, with an ember edge on a chip that is selected but offline; on these cards each TX and RX badge turns ember while its own entity is unavailable, each card’s icon is solid green while the part it shows answers (an Emitters card its emitter, a Receivers card its receiver, a Proxies card every part; a capture receiver’s follows its Listen chip) and turns into a hollow outline in ember when it does not, and a card whose hardware cannot be reached at all gets an ember edge and says OFFLINE in its corner.

Editing signals and commands

Every signal and command has a copy/edit glyph that opens a single editor: read the raw Pronto code, copy it, or replace it by pasting a new code or pressing LISTEN to capture it fresh off the remote, on the receiver named beside the button (its menu lists the others). The box takes one code at a time, as Pronto, as a Tuya or Broadlink base64 code, as a Global Cache sendir code, or as a Tasmota code; any of those is converted to Pronto and the editor says which format it came from. A file of many codes goes to the Closet instead. Editing updates the fingerprint and decoded identity, and moves any trigger bound to that signal along with it. Renaming a command updates any action mapping that pointed at the old name. A device command is a copy of the signal it was assigned from, so editing a catalog signal in the Sniffer or Clipper does not change commands already assigned from it; edit the command on the device itself to change what that device transmits. If a signal’s carrier reads off the common IR standards, the editor offers a “Snap to N kHz” button that re-encodes it to the nearest standard (30, 33, 36, 38, 40, or 56 kHz) before you save.

The same editor carries the two transmit knobs. Send times is how many times the whole code goes out as independent presses, for gear that needs a repeat to register. Spacing is the gap between those presses, measured from the start of one to the start of the next, and it turns on as soon as send times rises above 1. The box opens on what the code is spaced at today, so the number you adjust is the cadence the command already has rather than a blank.

Spacing is exact on ESPHome and Broadlink emitters, which accept the whole burst in a single call and lay it out to the microsecond. Anything else keeps sending one frame per call at its own pace, and the editor says so under the field rather than promising a cadence it cannot hold. It also says when a code is simply longer than the spacing asked for, in which case the presses go out back to back, and it refuses a combination that would hold the air for more than three seconds. Commands and signals saved before this existed carry no spacing and transmit exactly as they always did; opening one and saving it is what gives it a value.

Device settings and power sensing

IR devices are send-only, so HAIR normally has to assume a command landed. Any device that plausibly draws current (AC, media player, fan, light, switch) shows a small settings button beside its emitter picker; open it to point a sensor at the device: a smart plug’s wattage reading, or an on/off entity (a binary sensor, switch, input boolean or device tracker, such as a TV’s network tracker). For a wattage reading, set two thresholds, and the device counts as off at or below the lower one and on at or above the higher one; an on/off entity counts as on when it is on or home and off when it is off or not_home. A live reading is shown once a sensor is picked. Readings past either threshold override what HAIR assumed from the last command sent, and keep doing so across a Home Assistant restart, so a device switched off with its original remote stops claiming to be on. After each command HAIR sends, the sensor gets a settle time (20 seconds unless set otherwise in the same settings, 0 turns it off) so a plug that has not yet reported the new draw cannot flip the device back; if the device never responded, the sensor still corrects it after the settle time, with the plug’s first report after the command. Devices without a sensor still restore their last-known state after a restart instead of resetting to blank.

On a state-matrix climate device the same dialog also takes a temperature sensor, a humidity sensor, or both, and the thermostat card shows a live reading under each. Display only, and a sensor reporting in a different unit than your installation converts automatically.

A few more things

• Emitter routing – each device can be pinned to one emitter or broadcast through several, so an AC command stays in one room while a TV Power command reaches every room at once.
• Eleven languages – the panel and setup wizard follow your Home Assistant profile language automatically; see Translations below.
• Glossary – the words HAIR uses (Device, Remote, wig, fitting, pin, comb) are defined in docs/glossary.md.
• Stability – what stays the same across every 1.x release (entities, events, wig files, stored data) and what does not is listed in docs/stability.md.

Entity platforms

Every device also gets a remote entity for arbitrary Pronto codes and a button entity for each learned command.

A fan with one button that steps through its speeds gets speed control once that button is mapped to Speed Cycle and the fan’s settings say how many speeds it has; HAIR presses it as many times as it takes, and since it counts presses rather than reading the fan, turning the fan off and on lines the count up again. One known gap: a handset pinned to the fan in the same room is heard by the fan and re-sent by HAIR, so the fan moves two steps while HAIR counts one.

ESPHome hardware

If your ESPHome device already has remote_transmitter and remote_receiver blocks, one addition registers both on HA’s native infrared platform:

infrared:
  - platform: ir_rf_proxy
    name: IR Emitter
    id: ir_proxy_tx
    remote_transmitter_id: ir_tx     # your remote_transmitter id
  - platform: ir_rf_proxy
    name: IR Receiver
    id: ir_proxy_rx
    receiver_frequency: 38kHz
    remote_receiver_id: ir_rx        # your remote_receiver id

Reflash, and the Devices tab shows the emitter with a TX-NATIVE badge and the receiver with RX-NATIVE.

For ready-made configs for common ESP32 boards (XIAO Smart IR Mate, Athom RF IR Remote, M5Stack IR Unit, generic ESP32s), see esphome/ in this repo. Not sure what to buy? Recommended IR hardware compares them, with prices and where to buy.

# --- IR Transmitter (TX) ---
remote_transmitter:
  id: ir_tx
  pin: GPIO9        # your IR LED pin
  carrier_duty_percent: 50%
  non_blocking: true

# --- IR Receiver (RX) ---
remote_receiver:
  id: ir_rx
  pin:
    number: GPIO8           # your IR receiver data pin
    inverted: true          # most receiver modules idle high; flip this if nothing ever decodes
    mode:
      input: true
      pullup: true
  clock_resolution: 400000  # 2.5us ticks; exact conversion, and it keeps the RMT divider legal on every ESP32
  idle: 80ms                # silence that ends a capture; clears every air-conditioner gap we know (Daikin ~35ms); 82ms is the cap on C3/S3
  receive_symbols: 384      # room for the longest press HAIR reads (Daikin 152, 293 pairs); ESPHome's default 192 cuts it
  # rmt_symbols: 384        # original ESP32 only: uncomment there; leave it out on the C3 and S3
  tolerance: 25%
  dump: all                 # chatty; remove once things work

# --- Register both on HA's native infrared platform ---
infrared:
  - platform: ir_rf_proxy
    name: IR Emitter
    id: ir_proxy_tx
    remote_transmitter_id: ir_tx
  - platform: ir_rf_proxy
    name: IR Receiver
    id: ir_proxy_rx
    receiver_frequency: 38kHz
    remote_receiver_id: ir_rx

Air conditioners and long messages

The idle value above is how much silence ends a capture. ESPHome’s own default is 10 ms, and that is shorter than the gaps inside a single air conditioner message: a Daikin press carries about 35 ms of silence in the middle of it. At 10 ms the receiver closes the capture in those gaps, so one press arrives as several codes, and because each piece looks like a different signal it can show up as several remotes in the Sniffer.

80 ms is the value to use, with clock_resolution: 400000 beside it. The ESP32’s receiver counts silence in clock ticks and caps the count, which at ESPHome’s default clock is about 32 ms on the C3 and S3 and 65 ms on the original ESP32, so a larger idle on its own fails validation with config 'idle' exceeds the maximum value of 32767us. The slower clock raises that ceiling to 82 ms on the C3 and S3 while keeping timings exact on every ESP32 chip, and 80 ms under it still clears the Daikin gap by more than double. The trade-off at high values is the opposite problem: hold a button down and the repeats start merging into one capture instead of arriving as separate presses. HAIR’s decoders split a merged capture back into frames per protocol, so this is a safe place to sit. Why these two numbers, and the alternatives if your remotes need something else, are in Receiver timing.

The receiver also needs room for a whole press. A Daikin 152 press is 293 mark-and-space pairs and a Mitsubishi Electric one 292, while ESPHome keeps 192 by default, so the capture stops partway and the press never reaches HAIR whole. receive_symbols: 384 fixes that on the C3 and S3. On the original ESP32 the capture also ends when the receiver’s share of the RMT memory fills, so it needs rmt_symbols: 384 as well, and that memory is shared with every transmitter and receiver on the board: on a board that also has a 433 MHz receiver, Receiver timing shows how to split it.

Translations

HAIR speaks eleven languages, and nine of them need a native-speaker review. Spanish has one already (thanks @Waterbrain). French, Japanese, German, Polish, Portuguese, Dutch, Italian, Russian, and Chinese were drafted by a programming assistant and are marked “reviewer wanted” inside each dictionary file. A native-speaker pass over one file is all it takes, and your name goes in the file as its reviewer. See Adding a language.

Contributing

See CONTRIBUTING.md for guidelines.

License

MIT. See LICENSE for details.