Linux in a Bit's Stuff
Reticulum is a per-packet encrypted mesh network that flood routes only one kind of packet, called an announce. Announces tell each node in the network the “next hop” to get to every other node on the network. Everything else is routed along a single path determined by those “next hops,” resulting in very efficient routing overall.
Reticulum is a fundamental re-imagining of what the internet can be, and a redefining of what many mesh networks are capable of. At its most basic it transports data like the internet has been doing for decades, but to leave it at that would be doing it a great disservice.
With Reticulum, anyone can make and join almost entirely self-organizing networks that work without any central authority. Networks can combine into a single larger network and networks can split apart into multiple smaller ones; as long as there is a path, Reticulum can form a connection.
Adequate initiator anonymity and strong per-packet encryption are required for multi-hop communication, and Reticulum is a peer-to-peer network so devices can directly connect to each other, securely and end-to-end.
Reticulum is versatile enough to connect over almost anything you can think of simultaneously; that includes things like LoRa, serial, and packet radio. Networks can grow to a truly global scale if built out properly, and Reticulum is designed to cope with extreme network topology and bandwidth differences almost entirely automatically.
There is already a surprisingly strong community building projects with Reticulum and its native formats and standards, though it is still in beta and not ready for production... yet ;)
When discussing something as novel as Reticulum, it's important to first understand how it works. Let's start by establishing some basic terminology.
RNS (or Reticulum Network Stack) is the reference implementation of Reticulum, written in Python. There are alternative implementations of Reticulum, like microReticulum (written in C++), but most are currently early in development.
Destinations are essentially 'endpoints' that allow for programs to receive data. They are more of a routing concept than a reference to a specific program or device, and a single physical device can host multiple different destinations. There are a few types of destinations:
Announces are special signed packets that contain a destination's address, public key, and some other information needed to establish end-to-end connectivity to said destination. They are propagated throughout a network by Transport Nodes and allow Reticulum to form multi-hop connections to destinations.
A Node is an instance of Reticulum. There is generally one per device, and a 'Shared Instance' is created to allow multiple programs to connect at once.
A Transport Node is an otherwise standard node that is set to route data via a single configuration option. Not all nodes route traffic because this wastes bandwidth and decreases the reliability of larger networks just to support Transport Nodes that will never route anything. Reticulum can technically work without Transport Nodes, but only directly connected nodes are able to communicate without them.
Nodes do not know anything about a network beyond their immediate neighbors. They can move around a network at will and can even move to completely separate networks and still become reachable. To make a destination reachable, a program simply needs to send an announce on any network it is connected to.
An Interface is a connection over any medium between two or more nodes.
And finally Identities represent any kind of verifiable identity of a person, machine control interface, or sensor. Identities are used to create multiple destinations cryptographically linked to that identity.
Transport Nodes forward data to a destination through a route determined by announces, which essentially tell every Transport Node the most efficient next hop for data sent to a specific destination. Destinations do not store any kind of map of the network as that would be incredibly inefficient.
When an announce for a destination is sent by a program, it will be automatically recorded and forwarded by any transport node, subject to some specific rules defined in the Reticulum manual that I will simplify:
The keys and path to a destination can be requested from a properly configured Transport Node if a node does not already have an announce from the destination it is trying to reach.
There are more specifics about the routing, connection, and encryption processes in the Reticulum manual, but these basics should help you form a reasonable understanding of the concepts behind Reticulum's incredibly efficient routing strategy that allows Transport Nodes to directly pass data to a destination without needing to know the network's topology.
As mentioned previously, Reticulum can work over basically anything. There are limits though, and it's worth going over a few of the specifics.
The reference implementation of Reticulum (RNS) currently supports connections over any Ethernet, WiFi, KISS mode packet radio, or serial connection, as well I2P, TCP, and UDP. LoRa is also supported via RNode, a digital radio transceiver program designed for things like Reticulum, supporting many common LoRa boards.
Of course that doesn't mean Reticulum only supports these interfaces, currently any connection faster than 5 bits per second that can send packets 500 bytes or larger are supported, so that means basically anything you can imagine, as long as the work is put in to support it. There is even a very easily utilized generic "pipe" interface that can use any external program as an interface, so you can add new devices without even touching Reticulum code!
As long as two or more devices are somehow connected together, either directly or through devices with a Transport Node running, they can form a network. Remember that because of Announces, Reticulum is self-organizing and can form a network over any and all of these interfaces simultaneously. Once the interfaces are set up and the necessary nodes are set to be transports, you're basically done with any network configuration!
Interfaces also have special announce propagation rules that can be enabled, known as Interface Modes, allowing for more advanced network configuration and helping mitigate edge cases.
So that's great, but what's the point of a network stack that nothing makes use of yet?
That is why the Reticulum creators made LXMF, a Reticulum-native message format that enables standard long and short form messaging functionality, communication between networked devices, paper messages, and offline reception of messages.
Offline messaging is facilitated by LXMF Propagation Nodes, which store and forward messages to nodes that are not directly reachable when a message is sent. Messages stay encrypted the whole time, and only reveal the sender to the recipient.
Propagation Nodes will, by default, peer with each other and synchronize messages over time, automatically creating an encrypted, distributed message store. Users can retrieve their messages from any available Propagation Node.
Important Note:
LXMF's Propagation Nodes are not the same as Reticulum's Transport Nodes; Propagation Nodes provide optional asynchronous messaging features to LXMF while Transport Nodes enable multi-hop routing at the Reticulum level.
Now that I've explained how Reticulum works, let's try it out!
There are three major LXMF clients currently available, NomadNet, Sideband, and Reticulum MeshChat.
NomadNet is a desktop Terminal-based option with some features such as website-esque pages; while Sideband is a GUI app for both desktop and Android which is somewhat easier to use and can send images and files in chats.
Reticulum MeshChat's goal is to be even easier to use than Sideband, while keeping most of both Sideband and NomadNet's features. It has a very nice interface and adds even more features like voice calling and voice messages, while still working over LoRa.
To install any of the clients, follow the instructions on their Github pages:
Reticulum MeshChat - https://github.com/liamcottle/reticulum-meshchat
Sideband - https://github.com/markqvist/Sideband
NomadNet - https://github.com/markqvist/nomadnet
Once you've picked a client and installed it, you will need to configure some interfaces so you can connect to a larger Reticulum network. In Sideband this is done through the "Connectivity" and "Hardware" pages, with NomadNet it is done through config files in the hidden .nomadnetwork and .reticulum folders in your home directory, and with Reticulum MeshChat it is done through the "Interfaces" page.
The easiest way to get connected to other people and try out Reticulum is to join the testnet, you can find more info about that at https://reticulum.network/connect.html
Remember that when changing any of these options, you must completely restart your client for changes to apply.
Both NomadNet and Sideband have integrated guides explaining how to access and use their specific features, and I highly recommend reading them to better understand how to use each one.
You may even discover some less obvious features like Sideband's situation tracking functionality that, if enabled, allows groups to be easily organized and located at a glance, and the Repository page, which allows for the Sideband app to be shared offline!
For NomadNet specifically, make sure to pay attention to the keyboard shortcuts bar at the bottom of the screen. Each panel has different shortcuts that allow for a ton of functionality that you might otherwise miss.
So that's pretty much it for Reticulum's basics. To learn more, I highly recommend taking a look through the Reticulum Manual and Michael Faragher's Reticulum Primer, checking out the resources on Unsigned.io, and chatting with the Reticulum community in the Discussions tab on GitHub and in the Matrix room.