The Mesh
Has a Web

What is
Nomad Network?

Nomad Network is a distributed content and communication platform built entirely on top of Reticulum. It was created by Mark Qvist — the same person who wrote Reticulum itself — and it answers a question that most mesh networking projects never ask: once you have a radio network that works, what do you actually do with it?

The answer Nomad Network gives is: you build a web. Not the World Wide Web — no IP addresses, no DNS, no servers to subpoena — but a genuinely distributed publishing layer where any node on the Reticulum network can host content and any other node can retrieve it. Pages travel over LoRa radio, TCP, serial links, and any other interface Reticulum supports. They're encrypted in transit. They're addressed by cryptographic hash, not by domain name. And they're served directly from the device that owns them.

This is what the mesh looks like when it grows up. Meshtastic gets people talking. Nomad Network gives them something to say — and a permanent, censorship-resistant place to say it.

What You Can Do with It

Where It Fits
in Reticulum

Reticulum is the networking layer. It handles routing, identity, encryption, and transport — over any physical medium. NomadNet is an application built on top of Reticulum, in the same way that a web browser is an application built on top of TCP/IP. The two are distinct but inseparable: NomadNet without Reticulum is a program with nowhere to go. Reticulum without NomadNet is a protocol with no user-facing application to show for it.

The Application Ecosystem

NomadNet isn't the only application built on Reticulum — it's the oldest and most featureful. Here's how it relates to the other major apps:

The µ-Page
System

A µ-page (micro-page) is a document hosted on a NomadNet node and addressed by the node's Reticulum destination hash. When you request a page, NomadNet opens an encrypted link to the destination, sends the page path over that link, and receives the content in response. No HTTP. No TLS handshake. No DNS lookup. The routing, authentication, and encryption are all handled by Reticulum at the transport layer.

Pages are written in Micron — a simple, lightweight markup language designed for the constraints of radio transmission. It's not HTML. It's closer to a structured plain-text format that supports headings, emphasis, color, and clickable links. Nodes transmitting over LoRa have limited bandwidth, so Micron keeps pages small by design.

Micron: Source vs. Rendered

Here's how raw Micron source translates to formatted output:

Micron Syntax Reference

Installing
NomadNet

NomadNet requires Python 3.7 or higher and an active Reticulum instance. If you don't have Reticulum running yet, see Field Guide Vol. 1 first. NomadNet will connect to whatever Reticulum interfaces you have configured — LoRa, TCP, or both.

$ pip install nomadnet

$ nomadnet

# ~/.reticulum/config
[interfaces]

  [[Dublin Testnet]]
    type = TCPClientInterface
    enabled = yes
    target_host = dublin.connect.reticulum.network
    target_port = 4965

  [[Frankfurt Testnet]]
    type = TCPClientInterface
    enabled = yes
    target_host = frankfurt.connect.reticulum.network
    target_port = 4965

Restart rnsd (or NomadNet) after editing the config. You should see both interfaces show as active in the status bar.

Connecting to
the Network

Before you can browse a µ-page, Reticulum needs a path to the destination — a routing entry that tells it how to reach that node's hash. Paths propagate through the network via announces: when a node comes online, it broadcasts a signed announce that ripples out through every relay and transport node that receives it. Your local Reticulum instance stores these paths in a path table.

In practice: if a node is online and reachable, you'll have a path to it within a few minutes of connecting to the network. If you try to fetch a page before the path exists, Reticulum will send a path request and wait for a response. NomadNet handles this automatically — it just takes a moment longer the first time.

Understanding Destination Hashes

Every NomadNet node is identified by a destination hash — a 32-character hexadecimal string derived from the node's cryptographic identity and application name. It's the address you navigate to, equivalent to a domain name — except it's generated locally, requires no registration, and is impossible to spoof.

# Example destination hash
abb3ebcd03cb2388a838e70c001291f9

# To request a specific page on that node:
abb3ebcd03cb2388a838e70c001291f9/pages/about.mu

# Default page (index.mu) if no path is specified:
abb3ebcd03cb2388a838e70c001291f9

Finding Your Own Hash

Once NomadNet is running, your node's destination hash is displayed in the interface. You can also retrieve it from the command line:

$ rnid
Identity  : <your identity hash>
Destination: <your node destination hash>

Share your destination hash with others to let them reach your node — or publish it in a node directory.

Browsing with
the Terminal Client

NomadNet's built-in interface is a full-featured ncurses terminal application. It's split into panels: a message thread on the left for LXMF conversations, and a node browser on the right for navigating µ-pages. The two panels can be toggled, resized, and navigated entirely from the keyboard.

Key Bindings

The Split-Pane Layout

Here's what the NomadNet interface looks like. The left panel handles LXMF messages. The right panel is the µ-page browser. Focus switches between them with Tab.

Navigating to a Node

abb3ebcd03cb2388a838e70c001291f9

Known Nodes &
What's Out There

The Nomad Network doesn't have a central directory — that would defeat the point. But the community maintains informal lists of known nodes, and several official testnet hubs run by unsigned.io (Mark Qvist's project) serve as well-known starting points. Once you connect to any of these, you can follow links to discover others.

Running Your
Own Node

Running a NomadNet node makes you a publisher on the mesh. Your node gets a permanent destination hash, can serve µ-pages to anyone who connects, and can optionally propagate LXMF messages for others — extending the effective reach of the network.

The simplest setup is just running nomadnet with the default configuration. It will serve whatever pages you place in the pages directory and announce itself to the network. For a permanent node, you'll want to run it on a Raspberry Pi or similar always-on machine.

Configuration File

NomadNet's config lives at ~/.nomadnetwork/config. The defaults are sane — but these are the settings worth knowing:

ini# ~/.nomadnetwork/config

[node]
# Enable serving pages to other nodes
enable_node = yes

# Your node's display name
node_name = My Node

# Announce every N seconds (3600 = once per hour)
announce_at_start = yes
announce_interval = 3600

# Propagate LXMF messages for others
enable_propagation = no

[paths]
# Where your pages live
page_path = ~/.nomadnetwork/pages

Page Directory Structure

~/.nomadnetwork/pages/
├── index.mu          # Default page (fetched when no path given)
├── about.mu          # Reachable at hash/about.mu
└── links/
    └── directory.mu  # Reachable at hash/links/directory.mu

Writing
Micron Pages

Micron files are plain text with a .mu extension. You can write them in any text editor. There is no compilation step, no build system, no dependencies — save the file and your node serves it immediately.

The design philosophy of Micron is constraint as a feature. Pages are small by necessity, which means they load fast over radio links and stay focused. A good µ-page is concise, clearly structured, and links generously to other nodes and pages. Think gopher, not the modern web.

A Complete Example Page

micron# index.mu — a simple node home page

> Node Star · Mesh Networking Resources

>> About This Node

Welcome to the `!Node Star`!! Reticulum node.
Running LoRa at 915 MHz · Long Beach, CA

---

>> Pages

`[Field Guides`=/pages/guides.mu`
`[Node Directory`=/pages/directory.mu`
`[About`=/pages/about.mu`

---

>> Other Nodes

`[Dublin Hub`=abb3ebcd03cb2388a838e70c001291f9/index.mu`
`[Frankfurt Hub`=ea6a715f814bdc37e56f80c34da6ad51/index.mu`

---

`Fgreen`Status: Online · `f`Updated 2026

Tips for Good µ-Pages

• Keep pages short — LoRa links have limited bandwidth. Under 4 KB is ideal.
• Always have an index.mu — it's what people see when they navigate to your hash with no path.
• Link generously. Pages that link to other nodes help the community discover each other.
• Use headings to structure content. The > hierarchy renders clearly in both the terminal client and Nomad NetBrowser.
• Test locally — view your own pages in NomadNet before announcing.

Nomad
NetBrowser

The terminal interface is powerful, but it's not for everyone. If you'd rather explore the mesh web in a regular browser — with clickable links, formatted text, back/forward navigation, and bookmarks — Nomad NetBrowser is the tool for that.

It's a local web proxy built by Node Star. You run it on your machine, it connects to Reticulum, and it renders NomadNet µ-pages as clean HTML. Point Chrome, Firefox, or any other browser at localhost:5000 and navigate the mesh exactly as you would a website. No terminal required after setup.

Quick Start

$ sudo dpkg -i nomad-netbrowser_0.1.0_amd64.deb
$ nomad-netbrowser

$ pip install rns nomadnet flask
$ python3 nomadbrowser.py

What It Looks Like

Reference &
Resources

Key Resources

Known Testnet Nodes

Reticulum Testnet TCP Endpoints