Mesh network notes

Reticulum notes

Shortest start if you focus on LoRa

Buy hardware that can run RNode firmware

Flash that hardware with RNode firmware

Choose what will run the RNS stack (phone, laptop, fixed PC, RPi)

download the RNS software

edit its configuration to point it at the RNode as necessary

(...and, if you're not just doing a local mesh, probably also interconnect it to nearby meshes, e.g. via TCP - more on tha tbelow)

and run it

Pick an app to use over it, probably chatting

Shortest start if you just want to see it work, no buying anything

If you don't care about the LoRa part, it's just the last two items from the previous section:

download the RNS software

edit the reticulum config to use whatever you want to connect to, probably internet servers in this case

run something that will start the RNS stack and pick up that config, and actually talk to others

Pick an app to use over it, probably chatting

What hardware do I need (LoRa)

In case it was not made clear elsewhere: If you have an RNode, you always need more than an RNode

An RNode is, by itself, not a participant / instance. An RNode is just a modem / radio peripheral - capable of sending what you tell it, but not of thinking up everything to do and send.

You always need to add something with some ability to do work (namely a bunch of cryptography).

If you run it on a laptop, that's that laptop.

If you pair it with a phone, your phone will happily do so.

If you want to set it up separately, that is often something you can stow away and forget, probably the minimum viable option is order of a raspberry pi

Notes:

• an RNode is a separate thing because it plus in a specific ability to a general stack

namely the ability to speak reticulum specifically over LoRa. Which is optional, but a sometimes very useful option.

• The Rnode being a modem is part of why it has quite low needs, which is why AVR implementations exist, and you can run it off even a smallish battery for a while

the ESP32 and nRF implementations are common largely for the convenience of provide bluetooth as well, which is especially handy if you want ease of use.

• if that reticulum stack is going to be seeing more than a little traffic (e.g. relay more than a little), then the minimum viable hardware to run the reticulum stack is probably the speed of a later-gen raspberry pi

(people have tried ESP32 or first-gen RPi. It seems that will function fine as a participant, but not as a node that would pick up relaying as it would be overwhelmed by higher traffic)

• there is no real distinction between 'occasional talker' and 'relay node', but practical context and setup will make you tend to become one or the other

(while there is no hard distinction, some settings hint things to others that you are a bad choice of relay)

---

More concretely:

There are no mass market "buy and put in corner" products.

...but there are various development boards that are specifically known to the reticulum developers, meaning they are one specific firmware flash away from being an RNode.

(This is in part why the lilygo and heltec boards are well known ...and also why there is a lot of overlap between the board used by this and by meshtastic and meshcore as well - though be aware that what each project supports a somewhat slightly different subset of the varied boards available, so not all boards with those general names on it are usable).

So most of us would buy hardware based on firmware specifically supporting it.

There is a good list(verify) on https://github.com/liberatedsystems/RNode_Firmware_CE

The actual flashing is surprisingly smooth (compared to at l;east some of the other experiences in the DIY world).

And some people do sell the result of that inside a little box.

Or you could find a 3D printer design yourself.

Beyond that, you could piece together microcontroller and LoRa radio, but beyond the dev boards lies a gliding scale of DIY - and willingness and ability to tinker.

Even if it's made from the same specifically supported parts, is in part just how the parts are connected.

So you can cobble together your own, but would then need to think about board definitions and the likes.

Slight confusion:

As there isn't really a single authoritative page on those dev boards, you may find a few different places with talking about firmware and support that are out of date - the support may be better than what they suggest. For example

• You may see something mention mention that the heltec v4 isn't supported, that was primarily because of a few pin changes, and was added later.
• Or that nRF52 devices aren't supported yet - that's an old note too.
• https://github.com/markqvist/RNode_Firmware is not the up to date version, it's https://github.com/liberatedsystems/RNode_Firmware_CE
• I'm not even sure what the current rns's rnodeconf is based on exactly
• There is a web based flasher which can be much easier, buts (aotw) its drop-down has one or two boards less

Point is, these don't all have exactly the same set of boards, so depending on your preferences and your board, you may have to look around a little.

Config(-relevant) notes

interface configuration

✎ This article/section is a stub — some half-sorted notes, not necessarily checked, not necessarily correct. Feel free to ignore, or tell me about it.

Understanding what you're seeing

What are all these long numbery hexadecimal things?