Plug it in.
Join its Wi‑Fi.
You’re on the mesh.
RetiMesh Node turns a $30 ESP32 + LoRa board into a standalone Reticulum transport node. It routes for every peer around it over LoRa while your phone talks to it over ordinary Wi‑Fi — no host computer, no internet, no accounts, nothing to type.
rnsd does with
enable_transport = yes.
A Reticulum node,
not another protocol
Reticulum is a cryptography-first networking stack that runs over anything — LoRa, packet radio, TCP, a serial cable. RetiMesh Node is that stack, embedded in firmware, on a board you can hang off a battery and forget about.
Standalone transport
The firmware embeds microReticulum, a C++ port of RNS, with transport enabled: a live path table, announce propagation with hop counts, path requests answered from its own table, packets forwarded hop by hop. No companion computer anywhere in the picture.
Transparent bridge
Packets cross between Wi‑Fi and LoRa unmodified in both directions. The node holds no keys belonging to anyone else and reads nothing it carries — end-to-end encryption stays strictly between the Reticulum peers, with their own identities.
RNode-compatible RF
The LoRa wire format — one header byte, ≤255-byte frames, two-fragment packets up to the 500-byte RNS MTU — is byte-identical to RNode_Firmware. Real RNodes on the same channel parameters simply work with it. Nothing proprietary goes on the air.
rnsd’s vocabulary and their own
admin API; off-grid and emergency users who need local messaging with no infrastructure; and
tinkerers who want a documented codebase, a board registry and a web flasher for their own hardware.
Two cores, two rings,
four ways in
Radio timing is never blocked by web or Wi‑Fi work. The two halves of the node talk through FreeRTOS ring buffers that drop on overflow rather than block — because a stalled radio task is worse than a lost packet, and Reticulum links tolerate loss.
Task layout
| Core | Runs | Why there |
|---|---|---|
| Core 0 | Wi‑Fi / LwIP stack, the single AsyncTCP event task (sockets for ports 80 and 4242), captive-portal DNS poller | Networking is bursty and interrupt-heavy; it gets its own core |
| Core 1 | radioTask (transceiver IRQ service, CSMA, RNode framing) and bridgeTask (LoRa → TCP fan-out) |
LoRa timing is hard real time; nothing web-facing may pre-empt it |
| Between | Two ring buffers (RINGBUF_TYPE_NOSPLIT) — one item is one RNS packet |
Lock-free hand-off; both directions drop rather than stall |
Ways a host reaches the node
| Port | Protocol | Purpose |
|---|---|---|
| — | Wi‑Fi SoftAP retimesh-XXXXXX, 10.42.0.1/24 | Open network with captive-portal DNS; or join an existing LAN in station mode |
| 80 | HTTP | Status page, neighbour list, message log, public bulletin board, admin settings, retimesh.local |
| 4242 | Raw TCP, RNS HDLC framing | Reticulum transport — connect any stock RNS client |
| — | RNS AutoInterface (IPv6 link-local) | Zero-config discovery — Sideband’s Local/LAN finds the node by itself |
| 115200 | USB serial | The log, and a maintenance console (VERSION, STATUS, LINKS, MESSAGES…) |
| 4243 | TCP | The same console over the network |
| 10.64.n.1 | USB CDC-NCM (native-USB boards) | The node is an Ethernet link with DHCP — the whole web app and API over the cable, no Wi‑Fi |
| 10.65.n.1 | PPP over the serial bridge | Same again through pppd on CP2102 / CH9102 boards |
Client side — the whole configuration
# ~/.reticulum/config — or, in Sideband, just add a TCP Client Interface.
# With Local/LAN discovery on (the default) even this is unnecessary.
[[RetiMesh Gateway]]
type = TCPClientInterface
enabled = yes
target_host = 10.42.0.1
target_port = 4242
Each connected client gets its own RNS interface on the node, with its own mode.
Radio parameters must match every node on the channel — frequency, bandwidth,
spreading factor, coding rate and sync word — and are changed live on the settings page,
which prints the matching RNodeInterface block for you.
Everything the node does
once it is on
The whole product is on the board. There is no companion app, no service to sign up to and nothing that stops working when the internet does.
Zero-config onboarding
An RNS AutoInterface does IPv6 link-local discovery on the Wi‑Fi. Sideband’s Local/LAN connectivity finds the node within seconds of joining — no host, no port, nothing typed.
Captive-portal status page
Radio model and channel, RSSI/SNR, transport interfaces, the live path table, neighbours, and QR codes for Wi‑Fi join, portal URL and node address. Your OS pops it up on join.
Verified neighbour list
Announces heard from either side are parsed and signature-verified, then listed with aspect, hop count, display name and signal. LXMF peers get a Message in Sideband hand-off and an address copy button.
rnsd interface modes
full, gateway, access_point, roaming,
boundary — set separately for the LoRa channel, the TCP clients and the
discovered peers, because those are three different policies.
Message log
The last 50 LXMF messages the node itself was sent, newest first: whether the sender could be verified, how it arrived and what it said. “Did that get through?” has an answer on the node, not just in the sender’s client.
Public bulletin board
Deliberately plaintext and local to the node — anyone on its Wi‑Fi can post and read, no identity needed. 50 posts, rotated oldest-first.
Live admin settings
Radio channel applied without a reboot, Wi‑Fi security and SSID, transport modes, announce interval, admin password, factory reset. Everything in NVS, behind a password you are told to change on first use.
Station mode uplink
Point the node at your existing Wi‑Fi and it becomes a LoRa uplink for the whole LAN — every Reticulum client on the network reaches it by address or by discovery.
USB networking & PPP
On native-USB boards the node is a composite device: a console and a CDC-NCM Ethernet link
with DHCP. On bridge boards, pppd gives you the same over the serial cable. The full
web app and API, no Wi‑Fi involved.
Maintenance console
VERSION, STATUS, LINKS, MESSAGES,
WIFI ON, RESET CONFIRM, BOOTLOADER CONFIRM — over
USB serial or TCP 4243. The node can even hand its own bootloader over, so reflashing needs no
BOOT button.
Scriptable HTTP API
/api/status, /api/board, /api/settings/*,
/api/system/* — identity and destination hashes, radio stats, neighbours,
paths. Fleet provisioning and monitoring are a curl away.
Persistent identity
X25519 + Ed25519 keys in NVS, kept across a factory reset — the node keeps its address. The path table and announce cache live in a microStore on the SD card when one is present, internal flash otherwise.
Beacons & station IDs
Optional RM1 probes broadcast to the PLAIN destination retimesh.beacon
— valid RNS packets other clients silently drop, and any Python RNS script can listen to.
RNode station callsigns show up as neighbours too.
Displays that earn their pins
SSD1306 OLED status pages with neighbour counts and QR codes; a driven 2.13″ e-ink panel on the Wireless Paper; front LEDs on the headless Wireless Bridge. Absent panels compile out entirely.
Next to the things
you already run
RetiMesh Node is not competing with the Reticulum ecosystem — it fills the one gap in it: a node that is both the radio and the router, with nothing plugged into it.
| RNode firmware | Meshtastic | MeshChat | RetiMesh Node | |
|---|---|---|---|---|
| Role | Radio modem for a host RNS | Own protocol, own apps | Web client for RNS | Standalone RNS transport node + gateway |
| Needs a host computer | yes | no | yes | no |
| Reticulum-native | yes — via a host | no | yes | yes — embedded RNS |
| Phone onboarding | rnsd + Sideband config | vendor app | browser | join the Wi‑Fi, done |
| RF interop with RNode | — | no | — | yes — byte-compatible |
Interoperability is the point, not a feature: put an RNode and a RetiMesh Node on the same frequency, bandwidth, spreading factor, coding rate and sync word, and they are on the same mesh.
Thirteen boards,
four radio families
One boards.json registry drives the builds, the release packaging, the flasher and the
CLI — so every board here is built by CI on every commit. Sub-GHz LoRa, 2.4 GHz LoRa and
Semtech's LR11xx all run the same transport. Where the transceiver can be told apart at runtime it is
detected at boot, and a single image covers both variants.
Every board has its own page →
hardware, radio, a pin map drawn from its header, and exactly what this firmware drives on it.
LilyGO T3-S3 v1.2/v1.3 (SX1262 or SX1276/78)
t3s3- MCU
- ESP32-S3FH4R2: 4 MB flash, 2 MB PSRAM
- Radio
- SX1276/78 or SX1262 — detected at boot
- Panel
- 0.96" SSD1306 (I²C)
Generic ESP32-S3 DevKitC-1 + SX1262 module
esp32s3-qspi- MCU
- ESP32-S3: 8 MB flash, quad PSRAM
- Radio
- SX1262
- Panel
- optional SSD1306
LilyGO T-Beam v1.1/v1.2 (SX1276 or SX1262)
tbeam- MCU
- ESP32: 4 MB flash, 4 MB PSRAM
- Radio
- SX1276 (v1.1) or SX1262 (v1.2) — detected at boot
- Panel
- 0.96" SSD1306 (I²C)
LilyGO T-Beam Supreme
tbeam-supreme- MCU
- ESP32-S3FN8: 8 MB flash, 8 MB quad PSRAM
- Radio
- SX1262 in a socketed module (TCXO at 1.8 V, DIO2 drives the RF switch)
- Panel
- 1.3" 128x64 SH1106 (I²C) — not the SSD1306 the other OLED boards carry
LilyGO T3-S3 with SX1280 (2.4 GHz)
t3s3-sx1280- MCU
- ESP32-S3FH4R2: 4 MB flash, 2 MB PSRAM
- Radio
- SX1280
- Panel
- 0.96" SSD1306
LilyGO T3-S3 with SX1280 + PA (2.4 GHz)
t3s3-sx1280-pa- MCU
- ESP32-S3FH4R2: 4 MB flash, 2 MB PSRAM
- Radio
- SX1280 + PA
- Panel
- 0.96" SSD1306
Heltec Wireless Stick V2/V2.1
heltec-ws- MCU
- ESP32: 8 MB flash
- Radio
- SX1276
- Panel
- 0.49" 64x32 SSD1306 on Vext
Heltec Wireless Bridge
heltec-wb- MCU
- ESP32-D0WDQ6: 8 MB flash, 8 MB PSRAM
- Radio
- SX1276
- Panel
- — (headless)
Heltec WiFi LoRa 32 V3
heltec-v3- MCU
- ESP32-S3: 8 MB flash, no PSRAM
- Radio
- SX1262 (TCXO, DIO2 drives the RF switch)
- Panel
- 0.96" SSD1306 on the switched Vext rail
Heltec Wireless Paper
heltec-wp- MCU
- ESP32-S3: 8 MB flash, no PSRAM
- Radio
- SX1262 (TCXO, DIO2 drives the RF switch)
- Panel
- 2.13" e-ink (250x122, E0213A367), driven
Heltec V4 (TFT)
heltec-v4- MCU
- ESP32-S3: 16 MB flash, 2 MB PSRAM in package
- Radio
- SX1262 (TCXO, DIO2 drives the RF switch) behind a GC1109 or KCT8103L front end
- Panel
- 2.4" 240x320 ST7789 with a CHSC6X touch layer
LilyGO T-Deck
t-deck- MCU
- ESP32-S3: 16 MB flash, 8 MB octal PSRAM in package
- Radio
- SX1262 (TCXO at 1.8 V, DIO2 drives the RF switch), no amplifier
- Panel
- 2.8" 320x240 ST7789 with a GT911 touch layer
Elecrow ThinkNode M9
thinknode-m9- MCU
- ESP32-S3: 16 MB flash, 8 MB octal PSRAM in package
- Radio
- Semtech LR1110 (TCXO at 3.3 V, the chip drives its own antenna switch from DIO5/DIO6)
- Panel
- 2.4" 320x240 ST7789, no touch layer
[env:…] in platformio.ini, a pin map in
src/boards/<name>.h, and an entry in boards.json — CI, the release
packaging, this flasher and the CLI all pick it up from there. Ports in progress include the RAK WisBlock 4631 (nRF52, needing a platform-layer port),
Xiao ESP32S3 + Wio-SX1262 and the LR1121 variants.
Flash it from
this page
Firmware comes straight from the latest GitHub release. Chrome or Edge on a desktop, a USB cable, about ninety seconds. No toolchain, no account, nothing to install.
Web flasher
▲ Could not reach the firmware index. Use the hosted flasher or the CLI below.
Tick Erase device on a first install so the filesystem and settings start clean. Everything is fetched over HTTPS and verified against the release’s published SHA-256 sums.
Then
- Connect the board over USB. If the port does not appear, hold BOOT, tap RST, release BOOT.
- Pick your board above, click Install, choose the serial port in the browser prompt.
- Join the open Wi‑Fi network retimesh-XXXXXX — the last three octets of the board’s MAC, also shown on the display.
- The captive portal opens at http://10.42.0.1/. In Sideband, Local/LAN connectivity finds the node on its own.
- Change the admin password at /settings.html — it ships as
admin/retimesh.
Terminal — Linux, macOS, Windows
pipx run --spec "git+https://github.com/dobrevit/RetiMesh_Node#subdirectory=tools/retimesh-flash" retimesh-flash install
Lists boards, auto-detects the port, verifies checksums and flashes with esptool.
--mode app keeps your settings; --mode fs updates only the web app.
Manual — esptool
pip install esptool esptool.py --chip esp32s3 --baud 921600 \ write_flash --erase-all 0x0 retimesh-node-<version>-<board>-merged.bin
Every release ships a merged image per board plus a zip of the individual partitions;
offsets and SHA-256 hashes are in that release’s release.json.
Free software,
and moving fast
or-later
RetiMesh Node is free software, released in full under the GNU General Public License v3 or later. Every line that runs on the board is published, and if you distribute or modify it you must pass those freedoms on: provide the corresponding source, keep the copyright and licence notices, and tell your users what rights they have.
Copyright © 2026 Dobrev IT Ltd. Third-party components keep their own licences — microReticulum and microStore (Apache-2.0/MIT), RadioLib, ArduinoJson, MsgPack (MIT), Adafruit GFX/SSD1306/BusIO (BSD/MIT), ESPAsyncWebServer and AsyncTCP (LGPL-3.0). The LoRa wire format is implemented for interoperability with RNode_Firmware; no RNode source is included.
Under heavy development
This is a pre-1.0 project on 0.0.x releases, shipping fast and changing in the open. Things move: settings gain fields, APIs gain endpoints, boards get added, and a board marked builds only here has genuinely never been powered on. The status of every board is stated plainly rather than rounded up.
The published roadmap is equally blunt about targets and non-goals: 0.1 transport you can trust and soak-test, 0.2 zero-config, 0.3 real battery numbers, 0.4 more boards, 0.5 mesh services. No cloud accounts, no telemetry and no always-online dependency are on the list — ever.
Bug reports, board ports and interop results are all welcome, and CI builds every board on every commit so a pull request tells you immediately whether it fits.