Reticulum

What is Reticulum?

Reticulum is a cryptography-based networking stack that enables secure, private communications over any medium. It works over WiFi, LoRa radio, packet radio, serial connections, and the internet - all at the same time.

Project Status (2026)

Reticulum reached its first production-stable release, RNS 1.0, in July 2025 and now runs on the 1.x series, with the legacy AES-128 handlers removed in favor of the current cryptography.¹

In December 2025 the project's founder, Mark Qvist, stepped back from public development. The protocol and its reference code are public-domain, so it keeps working untouched — but new fixes and enhancements now gather in a community fork, Reticulum Community Edition (Reticulum_CE), which is where you file issues and track development going forward.²

Key Features

• Zero Configuration - Works out of the box with automatic peer discovery
• End-to-End Encryption - All communications are encrypted by default
• Works Anywhere - Runs on Raspberry Pi, laptops, phones, even microcontrollers
• Low Bandwidth - Operates on links as slow as 5 bits per second
• No Internet Required - Build resilient networks that work offline

The Reticulum Ecosystem

Quick Start (5 Minutes)

Get Reticulum running on your system:

Step 1: Install

pip install rns

Step 2: Start the Daemon

rnsd

First run creates a default config at ~/.reticulum/config

Step 3: Check Status

rnstatus

Shows your active interfaces and connected peers.

Step 4: Install an Application

pip install nomadnet
nomadnet

NomadNet gives you encrypted messaging and network browsing in your terminal.

Sources

1. Reticulum (RNS) releases (markqvist/Reticulum) — RNS 1.0.0 production release (Jul 2025) through the current 1.x series; verified 2026-06-19.
2. Reticulum Community Edition (Reticulum_CE) — the community-maintained fork that carries the project forward; verified 2026-06-19.

Requirements

• Python 3.7 or newer
• pip (Python package manager)
• No root access required - runs entirely in userspace

Raspberry Pi (Recommended)

Use Raspberry Pi OS 64-bit for best performance.

Install Dependencies

sudo apt update
sudo apt install python3 python3-pip python3-dev build-essential

Install Reticulum

pip install rns --break-system-packages

Install Applications

pip install nomadnet --break-system-packages
pip install lxmf --break-system-packages
pip install lxst --break-system-packages  # Voice streaming

Debian / Ubuntu (Modern)

For Debian 12 (Bookworm), Ubuntu 23.04+, and similar systems that use PEP 668.

Option A: Use pipx (Recommended)

sudo apt install pipx
pipx ensurepath
pipx install rns
pipx install nomadnet
pipx install lxmf
pipx install lxst  # Voice streaming

Log out and back in for PATH changes to take effect.

Option B: Allow pip System-Wide

Edit ~/.config/pip/pip.conf:

[global]
break-system-packages = true

Then install normally with pip install rns

macOS

Requires Python 3.7+ (install from python.org or via Homebrew).

pip3 install rns

If you get permission errors:

pip3 install rns --break-system-packages

Add to your PATH if commands not found:

export PATH=$PATH:~/Library/Python/3.9/bin

Windows

Step 1: Install Python

Download Python 3.12+ from python.org

Important: Check "Add Python to PATH" during installation!

Step 2: Open Command Prompt

Press Win+R, type cmd, press Enter

Step 3: Install Reticulum

pip install rns

Android (Termux)

pkg update && pkg upgrade
pkg install python python-cryptography
pip install rns nomadnet

Verify Installation

After installing, test that everything works:

# Start the daemon
rnsd

# In another terminal, check status
rnstatus

You should see output showing your active interfaces. If rnsd is not found, reboot or add pip's bin directory to your PATH.

Run as System Service (Optional)

For always-on nodes (servers, Raspberry Pi), run rnsd as a systemd service:

Create Service File

sudo nano /etc/systemd/system/rnsd.service

Add this content (adjust User and paths as needed):

[Unit]
Description=Reticulum Network Stack Daemon
After=network.target

[Service]
Type=simple
User=pi
ExecStart=/home/pi/.local/bin/rnsd --service
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Enable and Start

sudo systemctl daemon-reload
sudo systemctl enable rnsd
sudo systemctl start rnsd
sudo systemctl status rnsd

Keeping Reticulum Updated

Update to the current release the same way you installed. With pip: pip install rns --upgrade. With pipx: pipx upgrade rns. RNode radio firmware is flashed by rnodeconf, which ships inside the rns package — no separate download.¹

Sources

1. Reticulum Manual — Getting Started Fast (1.3.5) — current install via pip/pipx and rnodeconf; verified 2026-06-19.

Configuration Locations

Reticulum searches for config files in this order:

First run creates ~/.reticulum/config with sensible defaults and one active local interface.

Config File Structure

The config file has two main sections:

[reticulum] - General Settings

[reticulum]
  # Enable shared transport (allows routing through this node)
  enable_transport = no

  # Share your identity (for remote management)
  share_instance = yes

  # Shared instance port
  shared_instance_port = 37428

  # Interface mode (for all interfaces by default)
  # Options: full, gateway, boundary, access_point, roaming
  interface_mode = full

[interfaces] - Network Connections

Each interface connects Reticulum to a network. You can have many interfaces active at once.

[interfaces]

# Local auto-discovery (finds other Reticulum nodes on LAN)
[[Default Interface]]
  type = AutoInterface
  enabled = yes

# Connect to a public transport node
[[RNS Testnet Amsterdam]]
  type = TCPClientInterface
  enabled = yes
  target_host = amsterdam.connect.reticulum.network
  target_port = 4965

View Example Config

See a complete example configuration with all options documented:

rnsd --exampleconfig

Application Config Locations

Enable Transport

To allow your node to route traffic for other nodes (recommended for always-on servers):

[reticulum]
  enable_transport = yes

Interface Types

Reticulum supports many interface types. Here are the most common:

AutoInterface (LAN Discovery)

Automatically discovers other Reticulum nodes on your local network. Enabled by default.

[[Default Interface]]
  type = AutoInterface
  enabled = yes

Advanced Options

[[Default Interface]]
  type = AutoInterface
  enabled = yes
  group_id = reticulum
  discovery_scope = link
  discovery_port = 29716
  data_port = 42671

TCPClientInterface (Connect to Server)

Connect to a remote Reticulum node over the internet.

Connect to Public Testnet

[[RNS Testnet Amsterdam]]
  type = TCPClientInterface
  enabled = yes
  target_host = amsterdam.connect.reticulum.network
  target_port = 4965

Connect to a Specific Server

[[My Server]]
  type = TCPClientInterface
  enabled = yes
  target_host = 192.168.1.100
  target_port = 4242

TCPServerInterface (Accept Connections)

Allow other nodes to connect to your server.

[[TCP Server]]
  type = TCPServerInterface
  enabled = yes
  listen_ip = 0.0.0.0
  listen_port = 4242

I2PInterface (Anonymous)

Connect through the I2P anonymous network. Requires an I2P router (i2pd or Java I2P).

Basic Setup

[[I2P]]
  type = I2PInterface
  enabled = yes
  connectable = no

Accept Incoming (Run a Node)

[[I2P]]
  type = I2PInterface
  enabled = yes
  connectable = yes

RNodeInterface (LoRa Radio)

Connect via LoRa radio using RNode hardware. This enables long-range, off-grid communications.

Basic RNode Configuration

[[RNode LoRa]]
  type = RNodeInterface
  enabled = yes
  port = /dev/ttyUSB0
  frequency = 915000000
  bandwidth = 125000
  txpower = 17
  spreadingfactor = 8
  codingrate = 5

What is NomadNet?

NomadNet is a terminal application that provides encrypted messaging, node browsing, and file sharing over Reticulum. It works on any bandwidth - even 300 bps radio links.

Features

• End-to-end encrypted messaging
• Distributed message store (messages wait for offline users)
• Browse pages hosted on other nodes
• Share files securely
• Works entirely offline with LoRa/packet radio

Installation

Standard Install

pip install nomadnet

With pipx (Recommended)

pipx install nomadnet

Running NomadNet

Interactive Mode

nomadnet

Opens the full text interface with messaging, network browser, and settings.

Daemon Mode

nomadnet --daemon

Runs in background without UI. Your node stays online and stores messages.

Navigation

Test Nodes

After connecting to the testnet, try visiting these nodes:

Use Ctrl+G and paste an address to visit.

What are NomadNet Pages?

NomadNet pages are micron-formatted (.mu) files that create browsable content on your node. Pages can be static text or dynamic Python scripts that pull live data from APIs, run shell commands, or interact with users.

Page Locations

Micron Markup Basics

Micron is a lightweight markup language for NomadNet. Here are the essential formatting codes:

What It Looks Like

Here's how micron markup renders in NomadNet (terminal UI):

┌─────────────────────────────────────────┐
│         Welcome to My Node             │  <- `c`!text`!`a (centered, bold)
│─────────────────────────────────────────│  <- -= (divider)
│                                         │
│  ► About                                │  <- >Heading
│                                         │
│    This is a Reticulum node running     │  <- plain text
│    NomadNet. We share resources and     │
│    stay connected off-grid.             │
│                                         │
│  ► Links                                │
│                                         │
│    [Articles]  [Tools]  [Contact]       │  <- `Ff00`[link`:/page]`f (red links)
│                                         │
└─────────────────────────────────────────┘

Static Page Example

A basic static page (save as index.mu):

`c`!Welcome to My Node`!`a

-=

>About

  This is a Reticulum node running NomadNet.
  We share resources and stay connected off-grid.

-=

>Links

  `Ff00`[Articles`:/page/articles.mu]`f
  `Ff00`[Tools`:/page/tools.mu]`f
  `Ff00`[Contact`:/page/contact.mu]`f

Dynamic Page Example

Dynamic pages use Python to generate content. Add the shebang and print formatted output:

#!/usr/bin/env python3
print("#!c=60")  # Refresh every 60 seconds

from datetime import datetime
import subprocess

print("`c`!NODE STATUS`!`a")
print("")
print(f"Updated: {datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}")
print("")
print("-=")

# Get system uptime
try:
    result = subprocess.run(["uptime", "-p"], capture_output=True, text=True)
    print(f"Uptime: `!{result.stdout.strip()}`!")
except:
    print("Uptime: Unknown")

print("")
print("`Ff00`[Back to Home`:/page/index.mu]`f")

Light Fighter Manifesto Pages

The LFM node runs several dynamic pages. Here are examples from our production setup:

Index Page (Home)

The main landing page with navigation links:

`c`Ff00`!LIGHT FIGHTER MANIFESTO`!`f`a
`cIndependent Publication`a
`c`F777Unfiltered. Uncensored. Unconventional.`f`a

-=

`c`Ff00`!`[ARTICLES`:/page/lfm_articles.mu]`!`f    `Ff00`!`[PROJECTS`:/page/projects.mu]`!`f    `Ff00`!`[RESOURCES`:/page/resources.mu]`!`f    `Ff00`!`[SHOP`:/page/shop.mu]`!`f`a

-=

>Reticulum Network

  `Ff00`!`[QUICK CHAT`:/page/chat.mu]`!`f
  Real-time messaging bridged to Matrix #Nomadnet room.

  `Ff00`[Node Status`:/page/node_stats.mu]`f
  Live statistics for this propagation node.

  `F777LXMF Direct:`f `F0f0lxmf@7a58372d270d58f6148946705a7ca665`f

-=

>Field Tools

  `Ff00`!`[HF PROPAGATION`:/page/hfprop.mu]`!`f
  Band selection with FreeDV DATAC recommendations.

  `Ff00`[Solar Conditions`:/page/propagation.mu]`f
  Real-time solar flux, K-index, and geomagnetic alerts.

  `Ff00`[Power Planner`:/page/powerplanner.mu]`f
  Calculate battery runtime for portable operations.

-=

>Live Data

  `Ff00`!`[CRYPTO TICKER`:/page/crypto.mu]`!`f
  Live XMR/BTC prices with LFM contribution rates.

  `Ff00`[GitHub Activity`:/page/github_feed.mu]`f
  Recent commits from LFManifesto repositories.

-=

`c`F777Light_Fighter_Manifesto Propagation Node`f`a
`c`!lightfightermanifesto.org`!`a

Crypto Ticker (Live API)

Fetches live prices from CoinGecko API:

#!/usr/bin/env python3
print("#!c=60")

import urllib.request
import json
from datetime import datetime

print("`c`!CRYPTO TICKER`!`a")
print("")

def fetch_prices():
    url = "https://api.coingecko.com/api/v3/simple/price?ids=monero,bitcoin&vs_currencies=usd&include_24hr_change=true"
    try:
        req = urllib.request.Request(url, headers={"User-Agent": "NomadNet/1.0"})
        with urllib.request.urlopen(req, timeout=10) as resp:
            return json.loads(resp.read().decode())
    except:
        return None

prices = fetch_prices()

if prices:
    xmr = prices.get("monero", {})
    xmr_usd = xmr.get("usd", 0)
    xmr_change = xmr.get("usd_24h_change", 0)
    
    color = "0f0" if xmr_change >= 0 else "f00"
    sign = "+" if xmr_change >= 0 else ""
    
    print(">MONERO (XMR)")
    print("")
    print(f"  `F{color}`!${xmr_usd:,.2f}`!`f USD")
    print(f"  `F{color}24h: {sign}{xmr_change:.2f}%`f")
    
    # Calculate contribution rates
    if xmr_usd > 0:
        print("")
        print(">LFM CONTRIBUTION RATES")
        print("")
        print(f"  Article ($25):    `F0f0{25/xmr_usd:.4f} XMR`f")
        print(f"  Field Doc ($10):  `F0f0{10/xmr_usd:.4f} XMR`f")
else:
    print("`Ff00Unable to fetch prices.`f")

print("")
print("`Ff00`[Back`:/page/index.mu]`f")

Interactive Chat

The chat page demonstrates user input and database interaction. Messages are bridged to Matrix via maubot.

Input Fields

Create interactive pages with input fields:

# Text input (width 20, name "callsign", default "N0CALL")
`<20|callsign`N0CALL>

# Submit button that links to processing page
`[SUBMIT`:/page/process.mu`callsign]

# Access in Python via environment variable
import os
callsign = os.environ.get("field_callsign", "")

Making Pages Executable

Dynamic Python pages must be executable:

chmod +x ~/.nomadnetwork/storage/pages/mypage.mu

Debugging Pages

Test dynamic pages from the command line:

cd ~/.nomadnetwork/storage/pages/
python3 ./mypage.mu

Check for syntax errors and verify output looks correct before accessing via NomadNet.

What is Sideband?

Sideband is a graphical LXMF messaging client that runs on Android, Linux, macOS, and Windows. It provides encrypted messaging, voice calls, file sharing, and telemetry.

Features

• End-to-end encrypted messaging
• Voice calls over LoRa
• Image and file transfers
• Location sharing with offline maps
• Telemetry and sensor data
• Works without Google services (Android)

Installation

Android

Download the APK from the Sideband releases page. No Google Play required.

• Download the .apk file
• Enable "Install from unknown sources" in Android settings
• Install the APK

Linux

pip install sbapp

Then run sideband from terminal.

macOS

Download the disk image from releases, or install via pip:

pip3 install sbapp

Windows

Download the pre-built ZIP from releases, or use pip with Python 3.12:

pip install sbapp

Configuration

Sideband stores its config in ~/.sideband/

Reticulum interfaces are configured in ~/.reticulum/config as usual.

What is LXST?

LXST (Lightweight Extensible Signal Transport) is a real-time streaming protocol for audio and voice over Reticulum. It provides end-to-end encrypted voice calls optimized for low-latency communication.

Key Features

• End-to-End Encryption - All streams encrypted with forward secrecy
• Low Latency - Optimized for real-time voice communication
• Multiple Codecs - OPUS (4.5-96 kbps), Codec2 (450-3200 bps for HF/LoRa)
• Works on Any Link - Adapts to available bandwidth automatically
• Voice Calls - Real-time telephony over Reticulum

Codec Options

Installation

pip install lxst

Raspberry Pi Dependencies

For audio I/O and Codec2 support on Raspberry Pi:

sudo apt install python3-pyaudio codec2
pip install smbus2 rpi-gpio

Using rnphone

LXST includes rnphone, a command-line voice call application:

# Start rnphone and wait for calls
rnphone

# Call a specific destination
rnphone <destination_hash>

Integration with Sideband

Sideband uses LXST for voice calls. If you have LXST installed, Sideband can make encrypted voice calls over any Reticulum link - including LoRa and HF radio.

rnsd - Network Daemon

Runs Reticulum as a persistent service. Required for other programs to use the network.

# Start daemon
rnsd

# Start as service (logs to file)
rnsd -s

# Show example config
rnsd --exampleconfig

rnstatus - View Status

Shows the status of all configured interfaces (like ifconfig).

# Show all interfaces
rnstatus

# Filter by interface name
rnstatus rnode

# JSON output (for scripts)
rnstatus -j

rnpath - Path Discovery

Look up and display paths to destinations on the network.

# Find path to a destination
rnpath <destination_hash>

# Show all known paths
rnpath -t

rnprobe - Connectivity Test

Test connectivity to a destination (like ping). The destination must support probe replies.

# Probe a destination
rnprobe <destination_name> <destination_hash>

# Probe with larger packet
rnprobe <destination_hash> -s 256

rncp - File Transfer

Transfer files securely between Reticulum nodes.

# Receive files (run on receiving machine)
rncp --listen

# Send a file
rncp file.tar.gz <destination_hash>

# Fetch a file from remote
rncp --fetch remote_file.txt <destination_hash>

rnx - Remote Command

Execute commands on remote systems.

# Listen for commands (on remote machine)
rnx --listen

# Execute a command
rnx <destination_hash> "ls -la"

# Interactive shell
rnx <destination_hash> -x

rnid - Identity Management

Generate and manage Reticulum identities, encrypt/decrypt files.

# Generate new identity
rnid -g ./my_identity

# Show identity info
rnid -i ./my_identity -p

# Encrypt a file for a destination
rnid -i <destination_hash> -e file.txt

# Decrypt a file
rnid -i ./my_identity -d file.txt.rfe

lxmd - LXMF Daemon

Run an LXMF message propagation node.

# Run as propagation node
lxmd --propagation-node

# Show example config
lxmd --exampleconfig

Public Transport Nodes

Community-maintained transport nodes. Add them to your ~/.reticulum/config to connect to the global network. Node availability may vary.

TCP Transport Nodes

Example Config

[[RNS Testnet Amsterdam]]
  type = TCPClientInterface
  enabled = yes
  target_host = amsterdam.connect.reticulum.network
  target_port = 4965

[[Chicago Nomadnet TCP]]
  type = TCPClientInterface
  enabled = yes
  target_host = rns.chicagonomad.net
  target_port = 4242

[[Beleth RNS Hub]]
  type = TCPClientInterface
  enabled = yes
  target_host = rns.beleth.net
  target_port = 4242

I2P Nodes (Anonymous)

These nodes are accessible via I2P for anonymous connectivity. Requires an I2P router running.

I2P Config Example

[[I2P]]
  type = I2PInterface
  enabled = yes
  connectable = yes
  peers = kfamlmwnlw3acqfxip4x6kt53i2tr4ksp5h4qxwvxhoq7mchpolq.b32.i2p, g3br23bvx3lq5uddcsjii74xgmn6y5q325ovrkq2zw2wbzbqgbuq.b32.i2p

LFM NomadNet Node

The Light Fighter Manifesto runs a public NomadNet node with live tools, chat, and resources.

Connect via TCP or I2P and browse to the node address in NomadNet to access LFM pages.

Official Reticulum Repositories

All official Reticulum software is maintained by Mark Qvist on GitHub.

Documentation

• Reticulum Manual: markqvist.github.io/Reticulum/manual/
• API Reference: markqvist.github.io/Reticulum/reference.html
• NomadNet Guide: github.com/markqvist/NomadNet README

LFManifesto Repositories

Light Fighter Manifesto maintains several Reticulum-related projects:

Community Resources

• Matrix: #reticulum:matrix.org (Official)
• Matrix: #General:matrix.lightfightermanifesto.net (LFM)
• Reddit: r/reticulum
• Mastodon: @[email protected]

Installing from Source

Clone and install directly from GitHub for the latest development version:

# Clone Reticulum
git clone https://github.com/markqvist/Reticulum.git
cd Reticulum
pip install .

# Clone NomadNet
git clone https://github.com/markqvist/NomadNet.git
cd NomadNet
pip install .

# Clone LXMFMonero
git clone https://github.com/LFManifesto/LXMFMonero.git
cd LXMFMonero
pip install -r requirements.txt

"Command not found" after pip install

Cause: pip installs commands to a directory not in your PATH.

Solution 1: Reboot

Log out and back in, or reboot. Many systems update PATH on login.

Solution 2: Add to PATH

Add pip's bin directory to your PATH:

Linux/macOS:

export PATH=$PATH:~/.local/bin

Add to ~/.bashrc or ~/.zshrc to make permanent.

"externally-managed-environment" Error

Cause: Newer Debian/Ubuntu systems block pip to protect system packages (PEP 668).

Solution 1: Use pipx

sudo apt install pipx
pipx ensurepath
pipx install rns

Solution 2: Use break-system-packages flag

pip install rns --break-system-packages

No Interfaces Showing

Cause: No interfaces enabled in config, or rnsd not running.

Check rnsd is running

ps aux | grep rnsd

Reset config

mv ~/.reticulum/config ~/.reticulum/config.bak
rnsd

This creates a fresh default config.

RNode Not Detected

Cause: Wrong serial port, permissions, or device not in bootloader.

Find the correct port

# List serial devices
ls /dev/tty*

# On Linux, usually /dev/ttyUSB0 or /dev/ttyACM0

Fix permissions

# Add user to dialout group
sudo usermod -a -G dialout $USER

# Log out and back in for changes to take effect

Getting Help

• Reticulum Manual: markqvist.github.io/Reticulum/manual/
• GitHub Issues: github.com/markqvist/Reticulum/issues
• Matrix: #reticulum:matrix.org