Panda_

Sounds a lot like something that could be used with https://reticulum.network to create networks that support multiple mediums.

Overall this post seems a bit like you've got a grudge against the project. Is it related to the fact you made a post about your vibe coded SPORE project which looks inspired by Reticulum?

Not including a link is quite odd...

There's a thread by the author of Reticulum [1] on recent flooding attempts of weird clients connecting, spamming path requests and leaving, and attempting to mitigate their impact on the nodes.

Yeah it seems like you are in fact right...

[1] https://rns.recipes/forum/general/rns-150-testing-traffic-pr...

Try disabling the default AutoInterface in the config, that can cause problems due to some routers choking on UDP. If it still crashes anything, that's almost certainly a bug you can report

There's a LoRa firmware at https://github.com/attermann/microReticulum_Firmware which looks to be fairly well supported

There's an RNS implementation in Go at https://github.com/Quad4-Software/Reticulum-Go but

> robust protection against abuse

I would say it has a fairly reasonable number of protections with things like being able to prioritise certain interfaces and controlling the announce rate from a node and rate limiting the number of announces a destination makes. What in particular is abusable?

Mark accepts outside contributions over LXMF using git patches. The main communication method is over Reticulum Relay Chat using clients like NomadNet (made by Mark, unintuitive but works well) which is basically IRC and is purely sending messages to everyone in that channel at that time and is centralised around self hosted servers.

Reticulum packets include a hop count of how many nodes it’s been through (to prevent packets looping indefinitely) and the destination address. Two way links use tables on each node to reverse the route back to the origin and don’t use origin addresses.

The worst part privacy wise could be the announce packets which include a hop count and the address for the origin so if you had enough interfaces you could roughly say where a node is on a network graph (geo locating that is an entire other problem)

Privacy also depends on what interfaces you communicate over, eg TCP reveals IP addresses to the nodes you directly connect to (combine with hop counts to see if a packet definitely originated from that node), LoRa gives an idea of how close it might be because of its range limits and the fact radio emissions can be located.

The author of Reticulum's take is that the implementation is the specification, so if another implementation works with the standard Python one and implements enough of it's features then it implements Reticulum.

I suppose it means it's easier to develop the protocol only having to update one Python codebase but it does mean other implementations are kinda in a state where there isn't anything to properly verify they work.

There's also a issue with quite a few vibe coded implementations that don't actually properly work filling the space.

People do use it but it's definitely a small community. It has the NomadNet Page protocol which is basically small no client side script webpages (forms and links only) in a fairly bandwidth efficient form.

RNS vs Yggdrasil has previously been discussed on HN: https://news.ycombinator.com/item?id=46689170

> share a single secret to become that specific closed network

No? Pretty sure that isn't true.

You get an address by creating a random private key public key combination (no collisions are ensured by entropy).

You then send an announce packet over all the connections to other nodes you have. This packet tells everyone else how to reach you and that you exist. To send packets to you they send to the connection they got your announce came from, then the node on the other end of that connection sends to where it got the announce from and so on until it reaches the origin node where the destination must be.

The manual at https://reticulum.network/manual/index.html is the best source of information on Reticulum but it isn't very beginner friendly.

Reticulum uses AES-256 encryption, which is considered quantum safe due to the sheer number of extra combinations adding 128 bits to AES 128 creates, including by NIST[1].

It uses AES because AES is extremely well tested and vulnerabilities have not been found.

The new quantum safe algorithms are still mostly in beta and a few have already been broken. They also have extremely large key lengths which breaks the fundamental idea of Reticulum being able to run over any almost any connection, including LoRa. See what the creator of Reticulum said on the topic [2].

[1] https://csrc.nist.gov/projects/post-quantum-cryptography/faq... "To protect against the threat of quantum computers, should we double the key length for AES now? (added 11/18/18)"

[2] https://github.com/markqvist/Reticulum/discussions/181#discu...

The ending notes about a mesh network remind me of the Reticulum Network Stack[1].

As far as I can tell, RNS is a networking protocol that attempts to provide a mesh network that can run over almost any bidirectional connection (and interconnect different types of connections) without centralisation (basically random addresses using encryption, and announces to make that address reachable).

It's kinda similar to Meshtastic and Meshcore but designed to be more generic for any connection. Compared to Meshcore it's less bandwidth efficient since it uses larger addresses but I like RNS more because it's more generic (it's intended to be fairly bandwidth efficient but at a larger more internet level scale than just kilobytes per second) and less proprietary than the Meshcore official ecosystem. Compared to Meshtastic, RNS is much more efficient since it doesn't use flood routing for every packet.

[1] https://reticulum.network/

Reticulum would probably be the best one for it. As far as I can tell there aren't any interfaces for it already, but if you can get a command that transfers data using stdin and sdtout, Reticulum has things like the PipeInterface https://reticulum.network/manual/interfaces.html

Saw this at https://discuss.privacyguides.net/t/im-getting-into-mesh-net... and thought it was interesting

The Reticulum Network Stack is a more generic lora capable protocol. It is intended to run over almost any two way link so it's less bandwidth efficient per packet than Meshtastic but in return it gives you packet routing rather than flooding. It can be run over TCP, LoRa, WiFi, etc.

https://reticulum.network/start.html has an overview and how to connect.

There is a manual with a lot more information on how it works and the ideas behind it at https://reticulum.network/manual/ however it's quite large and not really a user friendly guide

If you just want to play with it https://reticulum.network/manual/software.html has a list of clients and software using it.

Try https://archive.is/5GHWF

Personally I would use something like a Reticulum Network for this kind of thing with a simple Python script to establish a Link between the two devices and send a Resource.

I still use it on a couple of devices where I haven't been bothered to change the default. On devices I use a lot, I normally use Duckduckgo or Ecosia

Interesting... Looks like it would be good for RAG. Maybe add Ollama support for local hosting?