Everything in Reticulum starts with an identity: a pair of cryptographic keys, one for encrypting and one for signing. Nobody issues identities. Your software makes one, and it is yours for as long as you keep the file.

From an identity you create destinations, one for each thing you want to be reachable for: your messages, a Nomad Network node, a chat hub. Each destination has an address of 16 bytes, written as 32 hexadecimal characters, for example the ScotMesh Nomad Network node:

The address is worked out from the identity's public key and the name of the application, so it cannot be claimed by anyone else and does not depend on where you are connected. Move your laptop from home broadband to a LoRa radio on a hill and your address stays the same.

There is no directory of who is where. Instead a destination announces itself now and then: a small signed packet carrying its address, its public key and, optionally, a little application data such as a node's name.

Transport nodes pass announces on to their other interfaces, and each one remembers two things: which neighbour it heard the announce from, and how many hops away the destination is. That is a path. When a packet for that address arrives later, each transport node simply sends it on towards the neighbour it remembered. No node ever needs a map of the whole network.

If your software has not heard an announce yet, it does not have to wait for the next one: it can send a path request, and a node that knows the way answers on the destination's behalf.

Announces are rate-limited and carry a hop count, so a busy network does not drown in them. The flip side is that a node which announces rarely is hard to find; the Nomad Network and Running your own transport node pages say what interval to use.

Any Reticulum program can send and receive. Only a transport node forwards traffic for other people, and it does so because its owner set enable_transport = Yes. Clients (a phone running Sideband, a laptop running MeshChatX) usually are not transport nodes; the machines they connect to are.

A transport node only ever handles encrypted packets. It can see that a packet is going to an address, never what it says or who sent it: Reticulum packets carry no sender address at all. That is why peering costs a node's operator nothing in privacy.

The ScotMesh backbone is a transport node on the internet. A solar relay running the ScotMesh firmware is a transport node on LoRa. Connect the two and the radio and internet sides become one network.

For anything more than a single packet, two parties set up a link: an encrypted, verified connection agreed with fresh keys each time, so recording today's traffic does not help anyone read it after a key is later stolen (forward secrecy). Setting one up takes three small packets, which is why links work even over slow radio.

Browsing a Nomad Network page, transferring a file with rncp or opening an admin page on a ScotMesh firmware node all happen over a link.

Reticulum does not care what carries its packets. Each way in or out is an interface in the configuration, and a node can have as many as it likes:

TCP client or server

Carries traffic over: The internet or a local network

Typical use: Connecting to the ScotMesh backbone

I2P

Carries traffic over: The I2P anonymising network

Typical use: Reaching the backbone from behind CGNAT

RNode

Carries traffic over: LoRa radio, through an RNode

Typical use: Links with no internet at all, over kilometres

UDP / Auto

Carries traffic over: The local network

Typical use: Machines in the same house finding each other with no setup

Serial, KISS, AX.25

Carries traffic over: Cables, packet radio modems

Typical use: Point-to-point and amateur radio links

Interfaces also have a mode that decides how announces and path requests are treated on them: full (the default), gateway (answers path requests for the clients behind it), access point (for a node that serves passing devices), roaming (for a node that moves) and boundary (the edge between two networks).

Reticulum is designed to keep working when the link is terrible. It needs only half-duplex, it works down to around 5 bits per second, and a packet is never larger than 500 bytes. Over LoRa that decides how applications are built: the ScotMesh firmware keeps every page under a single radio packet so it loads first time, and messages are sent whole rather than streamed.

Most people's first use of Reticulum is messaging. Messages use LXMF, a message format that sits on top of Reticulum and is spoken by Sideband, MeshChatX and Nomad Network alike, so they can all message each other.

When the other person is online, a message goes to them directly. When they are not, it goes to a propagation node, which holds it until they reappear. Propagation nodes share their stored messages with each other, so it does not matter which one the recipient happens to use. The messages are encrypted for the recipient; the node that holds them cannot read them. ScotMesh runs one; see Propagation node.

• Connecting to ScotMesh: get on the network.

• Choosing a client: Sideband, MeshChatX, Nomad Network.

• Glossary: every term above, in a sentence or two.

• The Reticulum manual (reticulum.network/manual): the authoritative reference, written by Reticulum's author.