blog
2026-04-05
reticulumtutorialinstallationmesh-networkinggetting-started

Your First Reticulum Install (Software Only, No Hardware)

Install Reticulum on any computer, connect to the public testnet, and verify connectivity — no special hardware needed. A 5-minute quickstart.

Your First Reticulum Install (Software Only, No Hardware)

This is Part 2 of a 12-part series on building private, resilient communication networks with Reticulum, LoRa, and associated tools.

No radios, no special hardware. In this guide you'll install Reticulum on your computer, connect to the public testnet over the internet, and verify connectivity — all in about 5 minutes.

Prerequisites

  • A computer running Linux, macOS, or Windows
  • Python 3 and pip installed
  • An internet connection (just for this first test)

Step 1: Install Reticulum

pip install rns

On newer Debian/Ubuntu systems that block user pip installs:

pip install rns --break-system-packages

Or use pipx for an isolated install:

pipx install rns

This installs the Reticulum networking stack and all its command-line utilities: rnsd, rnstatus, rnpath, rnprobe, rncp, rnx, rnid, and rnodeconf.

Step 2: First Run — Generate Default Config

Just run any Reticulum utility to trigger first-time setup:

rnstatus

Reticulum will create ~/.reticulum/config with a default configuration. This default config enables the AutoInterface, which automatically discovers other Reticulum peers on your local network via link-local IPv6 — no routers or DHCP needed.

If you have other Reticulum nodes on your LAN, you're already connected. But most likely you don't yet, so let's connect to the wider network.

Step 3: Connect to the Public Testnet

Open ~/.reticulum/config in your editor. Add a TCP interface to the [interfaces] section that connects to a public testnet node:

[interfaces]

  [[Default Interface]]
    type = AutoInterface
    interface_enabled = True

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

Save the file.

Step 4: Verify Connectivity

Run rnstatus to see your active interfaces:

rnstatus

You should see output like:

AutoInterface[Default Interface]
   Status  : Up
   Mode    : Full
   Rate    : 10.00 Mbps
   Traffic : 0 B↑  0 B↓

TCPClientInterface[RNS Testnet Dublin]
   Status  : Up
   Mode    : Full
   Rate    : 10.00 Mbps
   Traffic : 12.45 KB↑  8.23 KB↓

Both interfaces showing Up means you're connected. The TCP interface will start receiving announce traffic from other nodes on the testnet almost immediately.

Step 5: Explore the Network

View known paths (destinations the network has told you about):

rnpath -t

This shows the path table — a list of destinations your node has learned about through announces. You'll see hashes like <c89b4da064bf66d280f0e4d8abfd9806> with hop counts and the interface they were learned from.

Resolve a specific path:

rnpath <destination_hash>

This tells you how many hops away a destination is and which interface reaches it.

What Just Happened

Here's what Reticulum did behind the scenes:

  1. Generated your identity — a unique Ed25519/X25519 keypair stored in ~/.reticulum/storage/identities/
  2. Started the AutoInterface — listening for local peers via IPv6 multicast on UDP ports 29716 and 42671
  3. Connected to the testnet — established a TCP connection to a public transport node in Dublin
  4. Started receiving announces — other nodes on the testnet broadcast their existence, and your node cached their public keys and paths
  5. Built a path table — your node now knows how to reach destinations across the network

No accounts were created. No personal information was transmitted. Your node generated a random cryptographic identity and started participating in the network.

Running Reticulum as a Background Service

If you want Reticulum to stay running (useful for later guides), you can run the daemon:

rnsd

Or in the background:

rnsd -s &

For a permanent setup, create a systemd service. Create /etc/systemd/system/rnsd.service:

[Unit]
Description=Reticulum Network Stack Daemon
After=multi-user.target

[Service]
Type=simple
Restart=always
RestartSec=3
User=YOUR_USERNAME
ExecStart=rnsd --service

[Install]
WantedBy=multi-user.target

Then:

sudo systemctl enable --now rnsd

Useful Commands Reference

Command What It Does
rnstatus Show interface status and traffic
rnstatus -m Continuously monitor interface status
rnpath -t Show the full path table
rnpath <hash> Resolve path to a specific destination
rnprobe rnstransport.probe <hash> Ping a transport node (if it has probes enabled)
rnid -g ./my_identity Generate a new identity keypair
rnsd --exampleconfig Print a verbose example config with all options

Troubleshooting

rnstatus shows the TCP interface as Down: - Check your internet connection - The testnet node may be temporarily unavailable — try again in a few minutes - Check for firewall rules blocking outbound TCP on port 4965

command not found after pip install: - Your pip bin directory may not be in PATH. Try python3 -m rnstatus or log out and back in - On pipx installs, run pipx ensurepath and restart your shell

AutoInterface shows no peers: - This is normal if no other Reticulum nodes are on your LAN - Make sure link-local IPv6 is enabled (it is by default on most systems) - Check that UDP ports 29716 and 42671 aren't blocked by a firewall

What's Next

You have a working Reticulum node connected to a global testnet. In the next guide, we'll install MeshChat and send your first encrypted message to another person on the network.

Previous: [Part 1 — WTF is Reticulum?] Next: [Part 3 — Send Your First Encrypted Message with MeshChat]

← back to index