OpenRX: four tiny ExpressLRS receivers, one hard RF build (2026)

The pick

OpenRX is a family of four open-source ExpressLRS receivers built around the ESP32-C3. The project gives you KiCad designs, fabrication files, hardware targets, and a clear choice between a small 2.4 GHz receiver and more complicated dual-band variants. Hackaday published its feature on August 22, 2026, inside this week's window. 1

Weekend verdict: OpenRX is a good weekend project if the weekend includes ordering a professionally assembled PCB and bringing up the firmware. OpenRX is a poor candidate for hand assembly on a hobby iron. The Lite board is only 10.0 × 11.5 mm, uses a six-layer 1.0 mm PCB, a QFN-32 MCU, 0201 passives, and a 2.4 GHz RF chain. 2 3

The project stands out because the design files are unusually close to a fabrication handoff. The repository contains the KiCad project, schematic, PCB, rule file, fabrication archive, position file, and CSV BOM for the Lite variant. The hardware uses the CERN-OHL-S-2.0 license. 4 5

Why it stands out

The OpenRX family keeps the flight-controller interface familiar while changing the receiver hardware underneath. Each board runs ExpressLRS and sends CRSF over a UART. The four variants share an ESP32-C3, a 3.3 V LDO, a Wi-Fi antenna, a status LED, and a 5 V input pad. The radio and antenna path changes with the variant. 3

The Lite variant is the sensible reference build for a first attempt:

It uses the SX1281 for 2.4 GHz operation.
It ends in an on-board ceramic ELRS antenna, so the finished receiver has no U.FL connector or external link antenna cable.
It sends telemetry at 13 dBm, or 20 mW, according to the project specification.
It flashes through UART, Wi-Fi, or Betaflight passthrough with the standard Unified_ESP32C3_2400_RX target.
It exposes solder pads for RX, TX, 5V, GND, and BOOT instead of using a large connector.

These choices reduce the number of mechanical parts. They also put more responsibility on the PCB layout and the RF assembly. The 2.4 GHz link antenna is a PCB-mounted component, while the ESP32-C3 uses a separate ceramic Wi-Fi antenna for over-the-air configuration. 2 3

Hackaday reported that the four receivers kept a connection beyond five kilometers in a test where a forest blocked the signal path. That is a report of the project's test, not an independent range guarantee for every build. The same article explains that the receiver combines an ESP32-class MCU with the SX1281 and uses Chirp Spread Spectrum modulation through ExpressLRS. 1

Pick a variant

The family has a useful progression from a simple 2.4 GHz board to a two-radio dual-band board. Pick the variant before ordering parts because the RF IC, oscillator, antenna interface, and target configuration change with the board. 2 3

Variant	Radio and band	Link antenna	Telemetry power	Size	Firmware path
Lite	SX1281, 2.4 GHz	47948-0001 ceramic antenna on the board	13 dBm / 20 mW	10.0 × 11.5 mm	`Unified_ESP32C3_2400_RX`; stock unified firmware
Lite-UFL	SX1281, 2.4 GHz	U.FL connector	13 dBm / 20 mW	10.0 × 11.5 mm	`Unified_ESP32C3_2400_RX`; stock unified firmware
Mono	LR1121, dual band	U.FL with PA/LNA and RF switch	Up to 22 dBm / 158 mW	10.0 × 17.3 mm	`Unified_ESP32C3_LR1121_RX`; fork branch required
Gemini	Two LR1121 radios, dual band and Xrossband	Two U.FL connectors	Up to 22 dBm / 158 mW	17.0 × 15.7 mm	`Unified_ESP32C3_LR1121_RX`; fork branch and dual-radio settings required

The Mono and Gemini boards add an LR1121, a RFX2401C PA/LNA, a SKY13373 RF switch, and a 900 MHz matching network. Gemini duplicates much of that chain. The technical write-up says the Lite and Lite-UFL use the SX1281 path without a PA/LNA or sub-GHz section. 3

The Lite-UFL version makes more sense when the receiver will live inside a carbon-fiber frame or an enclosure that blocks the on-board antenna. The Lite version keeps the assembly shorter. The Mono and Gemini versions make sense when the radio requirement justifies a harder RF build. They are poor first choices for a one-weekend experiment.

BOM and budget

The table below is the complete OpenRX-Lite fabrication BOM from the repository's CSV. The source groups identical passive parts by reference designator. The cost column is a planning allowance for one prototype quantity, not a price published by OpenRX. The official product page lists the assembled OpenRX Lite as coming soon and does not publish a retail price, so the project should be budgeted from the fabrication files rather than from a product listing. 6 7

Reference(s)	Qty	Exact value or part	LCSC / sourcing note	Planning cost
`U1`	1	ESP32-C3, QFN-32, 5 × 5 mm	The CSV names the device but leaves the LCSC field empty. Confirm the exact approved MPN before ordering.	$1.50–4
`U2`	1	TLV75533PDQNR, 3.3 V LDO	`C2861882`	$0.30–1
`U3`	1	SX1281IMLTRT, 2.4 GHz radio	`C2151551`; check stock before placing the order.	$2.50–6
`OSC1`	1	OW7EL89CENUNFAYLC-52M, 52 MHz TCXO	`C22434896`	$1.50–4
`X1`	1	CJ17-400001010B20, 40 MHz crystal	`C2875272`	$0.15–0.60
`AE1`	1	2450AT18A100E, Wi-Fi ceramic antenna	`C89334`	$0.20–1
`AE2`	1	47948-0001, ELRS ceramic antenna	`C152351`	$0.30–1.50
`FL1`	1	2450FM07D0034T, 2.4 GHz band-pass filter	`C2651081`	$0.30–1.50
`D1`	1	XL-1010RGBC-WS2812B, RGB status LED	`C5349953`	$0.20–1
`L1`	1	24 nH inductor	`C206441`	$0.05–0.30
`L2`	1	2.5 nH inductor	`C206435`	$0.05–0.30
`L3`	1	2.0 nH inductor	`C86125`	$0.05–0.30
`L4`	1	15 µH inductor	The CSV leaves the LCSC field empty. Verify the footprint and approved part in KiCad before ordering.	$0.10–0.80
`C1`, `C3`	2	15 pF, 0201	`C85891`	$0.05–0.30
`C4`, `C10`, `C15`, `C23`, `C25`, `C28`	6	1 µF, 0201	`C76935`	$0.10–0.60
`C5`, `C6`, `C9`, `C12`, `C13`, `C14`, `C17`	7	100 nF, 0201	`C76939`	$0.10–0.60
`C8`, `C11`, `C16`	3	10 µF, 0402	`C15525`; the CSV also records `C76991` as an alternate.	$0.15–1
`C19`	1	1 nF, 0201	`C66942`	$0.02–0.15
`C20`	1	470 nF, 0201	`C85926`	$0.02–0.15
`C21`, `C22`	2	1.2 pF, 0201	`C85895`	$0.05–0.30
`C24`, `C26`, `C27`	3	10 nF, 0201	`C2168164`	$0.05–0.30
`R2`, `R3`, `R4`, `R5`	4	10 kΩ, 0201	`C106225`	$0.05–0.30
`TP1`	1	`RX` solder pad, 1.2 × 2.0 mm	OpenRX shared footprint	included in PCB
`TP2`	1	`TX` solder pad, 1.2 × 2.0 mm	OpenRX shared footprint	included in PCB
`TP3`	1	`5V` solder pad, 1.2 × 2.0 mm	OpenRX shared footprint	included in PCB
`TP4`	1	`GND` solder pad, 1.2 × 2.0 mm	OpenRX shared footprint	included in PCB
`TP5`	1	`BOOT` solder pad, 1.2 × 2.0 mm	OpenRX shared footprint	included in PCB

The component subtotal is roughly $8–22 before board fabrication, assembly, shipping, and wastage. A practical prototype budget is $20–45 for parts and a small run of bare boards, plus $50–150 or more for outsourced assembly depending on the assembler and quantity. Those are planning numbers: the repository supplies the BOM and manufacturing data, while the project does not publish a live assembled-board cost. 5 6

The parts list also reveals the real cost of the build. The dollar value is modest. The production process is not. The board contains 0201 capacitors and RF parts, and the repository's technical notes call for a six-layer, 1.0 mm board with 0.09 mm track and clearance rules and 0.35 mm vias on a 0.20 mm drill. 3

Schematic and PCB

The Lite signal path is short:

5 V pad
  -> TLV75533 3.3 V LDO
  -> ESP32-C3 + SX1281 + clocks + RF network
  -> 47948-0001 ceramic ELRS antenna

ELRS air link
  -> SX1281
  -> ESP32-C3
  -> UART0 / CRSF
  -> RX/TX solder pads
  -> flight controller

Official render of the OpenRX Lite PCB, showing the ESP32-C3, the RF section, the antenna area, and the RX/TX/5V/GND/BOOT pads. — *The Lite render is from the official OpenRX repository. The board uses a six-layer 1.0 mm PCB and exposes the external interface through solder pads. 2 3*

The power section starts at the 5V pad and feeds the TLV75533. The regulator supplies the ESP32-C3, the SX1281, the two clocks, the status LED, and the RF network. The ESP32-C3 uses its own 40 MHz crystal and a 2.4 GHz ceramic antenna for Wi-Fi. The SX1281 uses a 52 MHz TCXO and sends its RF output through the 2450FM07D0034T filter to the 47948-0001 link antenna. 3

The radio interface stays deliberately small. GPIO6, GPIO4, and GPIO5 carry the SPI clock, MOSI, and MISO signals to the SX1281. GPIO7 and GPIO2 handle chip select and reset. GPIO3 and GPIO1 carry the radio busy and DIO1 signals. UART0 uses GPIO20 for serial receive and GPIO21 for serial transmit. The five external pads bring those functions to the builder without adding a connector. 3

The repository's Lite folder includes the .kicad_sch, .kicad_pcb, .kicad_dru, and project files. The fab folder includes copper, mask, paste, silkscreen, edge-cuts, drill, position, and job files. The source tree is therefore enough to inspect the design and send a fabrication package to a board house. 4 5

Choose the Lite version when an on-board antenna suits the airframe. Choose Lite-UFL when the antenna needs to move away from the receiver. The Lite-UFL keeps the same SX1281 RF circuit but terminates it in a 50-ohm U.FL connector. 3

Firmware and bring-up

OpenRX supplies the hardware target definitions. ExpressLRS supplies the unified firmware. The repository sets ExpressLRS 3.5.0 as the minimum version for the current target definitions. Lite and Lite-UFL use Unified_ESP32C3_2400_RX; Mono and Gemini use Unified_ESP32C3_LR1121_RX. 3

A Lite bring-up needs:

A way to provide a clean 5 V supply to the 5V pad and a common ground to GND.
A UART connection to RX and TX, or a flight controller that can provide Betaflight passthrough.
ExpressLRS firmware configured for the Unified_ESP32C3_2400_RX target.
An ELRS transmitter for an air-link test.
A flight controller or another CRSF-capable serial host for a useful output test.
A fine-tip soldering setup or outsourced assembly for the board itself.

The official OpenDrone page describes the Lite board as a 5 V, CRSF receiver that can flash through Wi-Fi or Betaflight passthrough. The page also shows the intended physical harness: the board, silicone cables, heat-shrink, double-sided tape, and a quick-start guide. A self-built board will need you to reproduce the wiring that a finished product would have supplied. 7

A safe order of operations

Inspect the manufactured board before applying power. Check the antenna footprints, the crystal and TCXO orientation, the QFN joints, and the five pad labels against the KiCad files.
Check for a short between 5V and GND before connecting a supply.
Apply a current-limited 5 V supply and confirm that the 3.3 V rail appears.
Use the BOOT pad during power-up only when the selected flashing method requires download mode. The technical notes map BOOT to ESP32-C3 GPIO9.
Flash the Unified_ESP32C3_2400_RX target over UART, Wi-Fi, or Betaflight passthrough.
Test the receiver on the bench with the transmitter close by, then check CRSF output at TX before mounting the receiver in a frame.
Add the receiver to the flight controller and configure the serial port only after the board passes the bench test.

The board's small size makes the inspection step more important than the firmware command. A single misplaced 0201 capacitor or a poor QFN joint can look like a software failure. The RF path also depends on the antenna, filter, ground plane, and six-layer stack-up, so a receiver that boots can still have a weak link.

Mono and Gemini need a different software path. The technical write-up says the LR1121 variants require an ExpressLRS fork branch for TCXO control and RF-switch handling. Gemini also uses a second radio reset and software chip-select configuration. Those variants should be treated as firmware-porting projects, not as a simple change of target name. 3

Reproduction difficulty: advanced

Rating: Advanced. The schematic is understandable, the repository is well organized, and the Lite firmware path is conventional. The physical build still requires RF PCB fabrication and very small-pitch assembly.

The difficulty comes from five specific jobs:

Fine-pitch assembly: The ESP32-C3 is a QFN-32 device, and several passives use 0201 footprints. A hot plate, stencil, microscope, and rework capability are more realistic than a soldering iron alone.
RF fabrication: The Lite board is a six-layer controlled-layout board. A two-layer bargain PCB or an unverified stack-up changes the transmission-line environment.
Antenna placement: The link antenna is part of the PCB's RF design. Keep the antenna edge, ground clearance, and surrounding copper consistent with the provided board rather than moving the part into a new enclosure without checking the layout.
Firmware target selection: The Lite board is simple only when the exact 2.4 GHz target is selected. The dual-band boards require additional firmware changes.
Debug access: The board has solder pads instead of a connector. Every reflash or serial test requires a temporary harness or a flight-controller connection.

The repository's own revision notes add an important boundary. The current rev2 files include layout changes that were made after a validated build and had not yet been fabricated at the time of the note. Treat the current repository as a design you must inspect, not as proof that every current revision has already flown in a finished airframe. 3

The fastest weekend plan is to order the Lite board assembled, prepare the ExpressLRS firmware and UART harness, and reserve the second day for power, flash, and CRSF checks. The slow plan is to hand-place the entire board. The slow plan adds a manufacturing problem before the RF and firmware problems have been isolated.

Build or skip?

Build OpenRX Lite if you want to learn how an ExpressLRS receiver is reduced to an ESP32-C3, an SX1281, a clock, a filter, a ceramic antenna, and a few pads. The project gives you the source needed to inspect the circuit, generate a board, and flash a known firmware target. The $20–45 parts-and-board estimate keeps the experiment affordable before assembly and shipping. 4 5

Skip the self-build when you need a receiver this weekend, lack a way to order fine-pitch assembly, or need a certified and already-tested flight component. The official OpenDrone listing is still marked as coming soon, so buying the finished board is a separate availability question. 7

For a weekend build, choose Lite, outsource the PCB assembly, verify the 5 V and 3.3 V rails, flash Unified_ESP32C3_2400_RX, and test CRSF before installing the receiver in a drone. That sequence keeps the project honest: the source files make the board reproducible, while the RF assembly still deserves advanced-level respect.

References

1
Open-Source ExpressLRS Receiver Reaches For Range
hackaday.com
2
OpenRX README
github.com
3
OpenRX technical write-up
github.com
4
OpenRX-Lite source tree
github.com
5
OpenRX-Lite fabrication files
github.com
6
OpenRX-Lite fabrication BOM
github.com
7
OpenRX Lite product page
opendrone.be