Build a NomadNet
Cyberdeck Terminal

This is a desk terminal built around a Heltec LoRa32 V4 — an ESP32-S3 board with a built-in 0.96" OLED, a 915 MHz SX1262 LoRa radio, and a u.FL antenna connector. Flashed with RNode firmware, it becomes a fully functional Reticulum interface device. Mounted to the left of a mechanical keyboard on an acrylic base with LED underglow and an external whip antenna, it becomes something you can actually show people.

The Heltec is doing real work here. It's not a Raspberry Pi pretending to be a radio — the LoRa transceiver is on the same board as the display. When rnsd runs on your host machine and sees the Heltec over USB serial, it has a 915 MHz link into the Reticulum backbone. The display shows live network status: peer count, interface state, announce traffic. The antenna on the bracket picks up actual mesh nodes in range.

This is the build for people who have already set up Reticulum and want the infrastructure to feel like infrastructure.

Everything below is available from AliExpress (longer shipping) or Amazon (faster, $10–20 more total). The Heltec V4 ships from AliExpress reliably in 2–3 weeks. The Heltec official store on AliExpress is legitimate — use it over third-party listings.

The base unifies everything into a single object. It's a piece of 3mm clear acrylic, elevated 15mm above the desk on brass standoffs, with an LED strip along the inside of the front edge. The clear acrylic transmits that light along its full perimeter — edge-lighting. A logo etched or stuck to the underside glows from below. The keyboard and display module mount on top via the same standoffs.

Cutting and drilling

Score the acrylic five or six passes with a utility knife against a metal straight edge, then snap over a table edge. Sanded edges actually diffuse LED light better than polished cuts — run 400-grit along the front edge. Drill at low speed with a 3.5mm bit; tape the surface at each drill point first. Acrylic cracks from heat and vibration, not pressure — slow is the only technique.

The Heltec WiFi LoRa32 V4 is doing three things simultaneously in this build: running the display firmware that draws the node map on its 0.96" OLED, driving the WS2812B LED strip via a GPIO pin, and acting as a Reticulum RNode interface — a LoRa transceiver that rnsd talks to over USB serial as if it were a radio modem.

The Heltec runs RNode firmware — the open-source firmware by unsigned.io that turns supported LoRa boards into Reticulum interface devices. When flashed, rnsd on your host machine detects the board over USB serial and uses it as a LoRa interface automatically. No custom serial protocol to implement, no bridge script needed for the radio link.

The RNode firmware also drives the OLED display — it shows interface state, frequency, and link activity natively. The display firmware in Section 07 runs as a secondary layer on top, adding the animated peer map to the OLED.

Install rnodeconf

# Python 3.7+ required
pip install rns

# Verify
rnodeconf --version

Flash the firmware

# Connect Heltec V4 via USB-C, then:
rnodeconf --autoinstall

# The tool will detect the board, download the correct firmware,
# and flash it. As of RNode firmware v1.84+, a dedicated Heltec V4
# target is available — select it if listed. If your rnodeconf
# version only shows "Heltec LoRa32 V3", that works too (same
# ESP32-S3 + SX1262 base), but you may under-utilize the V4's
# higher TX power (~28 dBm PA). Update rnodeconf first:
#   pip install --upgrade rns
# Watch the output — it will confirm "Installation complete".

# Verify the install:
rnodeconf --info /dev/ttyUSB0   # Linux
rnodeconf --info /dev/cu.usbserial-*  # macOS
rnodeconf --info COM3           # Windows (check Device Manager for port)

Antenna assembly

The u.FL connector on the Heltec V4 is small and fragile — seat the pigtail connector firmly but don't rock it. The pigtail runs inside the 3D-printed bracket housing to the SMA bulkhead, which is pressed into a 6.5mm hole in the bracket wall and secured with its nut from the outside. The whip antenna screws onto the external SMA thread. Keep the pigtail coax as short as possible and avoid kinking it — coax below 10cm runs fine without additional strain relief.

After flashing RNode firmware, the OLED already shows basic interface state. The sketch below extends that — it runs on top of the RNode firmware logic and adds a live peer-count readout, signal strength bar, and animated mesh topology to the display. It also drives the WS2812B LED strip with the breathing cyan underglow.

// NomadNet Terminal — Heltec LoRa32 V4
// Drives OLED node map + WS2812B underglow
// nodestar.net/builds/nomadnet-terminal

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <FastLED.h>

// ── OLED config (Heltec V4: 128×64, I2C on 17/18) ──
#define OLED_SDA   17
#define OLED_SCL   18
#define OLED_RST   21
#define SCREEN_W   128
#define SCREEN_H   64

// ── LED strip config ──
#define LED_PIN    45   // GPIO45 — safe, not used by LoRa or OLED
#define NUM_LEDS   30   // adjust to your strip length

// ── Serial from host (rnsd bridge) ──
#define BAUD_HOST  115200

Adafruit_SSD1306 display(SCREEN_W, SCREEN_H, &Wire, OLED_RST);
CRGB leds[NUM_LEDS];

// Node map state
#define NODE_COUNT 8
struct Node { float x, y, vx, vy; };
Node nodes[NODE_COUNT];

// Network state (updated from host via serial)
int  peerCount  = 0;
int  rssi       = 0;
bool linkActive = false;
char rxBuf[128];
int  rxIdx      = 0;

void setup() {
  Serial.begin(BAUD_HOST);

  // OLED init
  Wire.begin(OLED_SDA, OLED_SCL);
  pinMode(OLED_RST, OUTPUT);
  digitalWrite(OLED_RST, LOW); delay(20);
  digitalWrite(OLED_RST, HIGH); delay(20);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay(); display.display();

  // LED strip init
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(160);

  // Init floating nodes
  randomSeed(analogRead(0));
  for (int i = 0; i < NODE_COUNT; i++) {
    nodes[i] = {
      (float)random(4, 86),
      (float)random(12, 52),
      (float)(random(-8, 8)) / 30.0f,
      (float)(random(-8, 8)) / 30.0f
    };
  }
}

void readSerial() {
  while (Serial.available()) {
    char c = Serial.read();
    if (c == '\n' || rxIdx > 126) {
      rxBuf[rxIdx] = '\0';
      // Simple parse: "peers:4,rssi:-87,link:1"
      sscanf(rxBuf, "peers:%d,rssi:%d,link:%d",
             &peerCount, &rssi, (int*)&linkActive);
      rxIdx = 0;
    } else {
      rxBuf[rxIdx++] = c;
    }
  }
}

void drawNodeMap() {
  for (int i = 0; i < NODE_COUNT; i++) {
    for (int j = i+1; j < NODE_COUNT; j++) {
      float dx = nodes[i].x-nodes[j].x;
      float dy = nodes[i].y-nodes[j].y;
      if (sqrt(dx*dx+dy*dy) < 38)
        display.drawLine(nodes[i].x, nodes[i].y,
                         nodes[j].x, nodes[j].y, SSD1306_WHITE);
    }
  }
  for (int i = 0; i < NODE_COUNT; i++) {
    display.fillCircle(nodes[i].x, nodes[i].y, 2, SSD1306_WHITE);
    nodes[i].x += nodes[i].vx; nodes[i].y += nodes[i].vy;
    if (nodes[i].x < 3  || nodes[i].x > 89)  nodes[i].vx *= -1;
    if (nodes[i].y < 10 || nodes[i].y > 62)  nodes[i].vy *= -1;
  }
}

void drawStatusPanel() {
  // Right panel (x=92..127) — status info
  display.drawFastVLine(91, 8, 56, SSD1306_WHITE);
  display.setTextSize(1); display.setTextColor(SSD1306_WHITE);
  display.setCursor(94, 10); display.print(peerCount);
  display.setCursor(94, 20); display.print("peers");
  display.setCursor(94, 34); display.print(rssi);
  display.setCursor(94, 44); display.print("rssi");
  // Link indicator dot
  if (linkActive) display.fillCircle(110, 58, 3, SSD1306_WHITE);
  else            display.drawCircle(110, 58, 3, SSD1306_WHITE);
}

void updateLEDs() {
  // Exponential sine breathing — Node Star cyan
  float t = millis() / 2000.0 * PI;
  uint8_t b = (uint8_t)((exp(sin(t)) - 0.36) / 2.35 * 150);
  for (int i = 0; i < NUM_LEDS; i++)
    leds[i] = CRGB(0, (uint8_t)(212.0/255 * b), b);  // #00D4FF
  FastLED.show();
}

void loop() {
  readSerial();

  display.clearDisplay();
  // Header bar
  display.setTextSize(1); display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0); display.print("NOMADNET 915MHz");
  display.drawFastHLine(0, 8, 128, SSD1306_WHITE);

  drawNodeMap();
  drawStatusPanel();
  display.display();

  updateLEDs();
  delay(40);
}

With RNode firmware on the Heltec, Reticulum's configuration is straightforward. Add an RNodeInterface entry pointing to the board's serial port. When rnsd starts, it detects the RNode, confirms the firmware signature, and brings up the LoRa interface. From that point the terminal is a live mesh participant.

# Add this block to your existing Reticulum config
# Find your port: ls /dev/tty* | grep -i usb (Linux)
#                 ls /dev/cu.* (macOS)
#                 Device Manager → Ports (Windows: COM3, COM4, etc.)

[interfaces]

  [[NomadNet Terminal]]
    type = RNodeInterface
    enabled = yes
    port = /dev/ttyUSB0       # adjust to your port
    frequency = 915000000     # 915 MHz  (use 868000000 for EU)
    bandwidth = 125000        # 125 kHz
    txpower = 14              # dBm — conservative default. V4 supports up to ~22 dBm; check regional limits + antenna gain.
    spreadingfactor = 7
    codingrate = 5

#!/usr/bin/env python3
# Runs on host machine alongside rnsd
# Queries rnstatus every 30s, forwards to Heltec over serial
# pip install pyserial

import subprocess, serial, time, re

PORT     = "/dev/ttyUSB0"   # Heltec serial port
INTERVAL = 30              # seconds between updates

def get_status():
    try:
        out = subprocess.check_output(["rnstatus"],
              stderr=subprocess.DEVNULL).decode()
        peers = len(re.findall(r"Destination", out))
        rssi_m = re.search(r"RSSI.*?(-\d+)", out)
        rssi   = int(rssi_m.group(1)) if rssi_m else 0
        link   = 1 if "NomadNet Terminal" in out else 0
        return peers, rssi, link
    except:
        return 0, 0, 0

with serial.Serial(PORT, 115200, timeout=1) as ser:
    print(f"NomadNet bridge running on {PORT}")
    while True:
        peers, rssi, link = get_status()
        msg = f"peers:{peers},rssi:{rssi},link:{link}\n"
        ser.write(msg.encode())
        print(f"→ {msg.strip()}")
        time.sleep(INTERVAL)

3D-printed bracket

The display bracket holds the Heltec at a 15° forward tilt, provides a mount point for the SMA bulkhead (6.5mm hole in the rear wall), includes a cable channel for the pigtail coax and the LED strip leads, and has M3 inserts for mounting to the acrylic standoffs. Print in matte black PLA at 0.2mm layer height — no supports needed with the bracket oriented face-down. The tilt angle keeps the OLED readable from a seated position without requiring you to lean forward.

Surface texture

PLA straight off the printer looks fine. For the carbon-fiber texture in the reference renders: Plasti-Dip rubberized coating in matte black, two coats. Hydro-dipping with carbon-fiber hydrographic film is the higher-effort version and looks exactly right. Kits run $20–30 on Amazon.

Cable management

Route the keyboard USB and Heltec USB-C to a shared exit at the rear of the base through a compact 4-port hub mounted underneath with 3M dual-lock tape. The single cable exit to the host machine looks intentional rather than assembled. The LED strip leads should be routed inside the bracket housing — the 3D-printed STL has a channel for this.

Branding

Underside vinyl works immediately. For the etched-acrylic look: Ponoko or a local makerspace, laser-etch, $10–20. The etch catches the LED edge-light differently from vinyl — more diffuse, more permanent. Node Star SVG assets for both the NomadNet and Node Star logos are available at nodestar.net/assets.

"The mesh should feel like a place you inhabit, not a config file running in the background."

The natural next step is embedding a small SBC — a Bosgame mini PC, an old ThinkCentre mini, or a Pi 4 — either below the base or in a rear enclosure. At that point the Heltec is no longer slaved to a host machine over USB: it's a peripheral to a dedicated Reticulum node that lives inside the terminal itself. The keyboard types into that machine. The display queries it directly. The whole stack operates off one power cable and one USB run to a monitor.

The Nomad NetBrowser desktop application from Node Star runs natively on such a system, rendering NomadNet pages in a local browser window on a display that's part of the terminal enclosure. At that scale the build stops being a peripheral and starts being an actual mesh node with a UI.

Beyond that: the r/cyberdeck community has documented builds with integrated e-ink status displays, solar charging, NFC readers, and satellite fallback links. The acrylic base format scales. Everything in this guide is a starting point.

Questions, corrections, build reports: Please reach out through our contact page.