The Internet, Reinvented.

This runs a long range radio, 915 megahertz, no Wi-Fi. This runs on Wi-Fi, no long range radio. Different frequencies, different hardware, they have absolutely no way to talk to each other. Except, they just did. And that shouldn't be possible because these two devices don't share the same modulation technique, the same radio hardware, or even the same frequencies. And they definitely shouldn't understand each other. Unless what we think of as the internet isn't actually cables or towers, it's just routing.

And once you realize that, some very strange things become possible. And by the end of this video, I'm going to show you where this is all heading with one of the strangest rigs I've ever constructed. I'm still shocked that it actually worked. But first, you need to understand what made that possible. Over the past few years, covering decentralized radio tech, building nodes, breaking things, and testing systems that most people never even see, I kept seeing the same name come up over and over.

In the comments, in forums, in my DMs. A project I'd mostly ignored. Reticulum. Some people have started calling it the hacker network. Not because it's illegal, but because it represents a completely different philosophy about how communication should work. Open, autonomous, sovereign communication that doesn't rely on permission or centralized infrastructure. And instead of just talking about it, I decided to build one to see if the idea actually holds up in the real world.

But why do we need something like this at all? The problem is, today, our devices are very capable, diverse, and ever-changing. But despite that, when we attempt to communicate, our data must flow through remote infrastructure run by other people. So if I want to send a message to Amelia, she's literally downstairs in the same house, something strange happens. That message doesn't just go from my device to hers. Instead, the packet leaves our home network, travels out to remote infrastructure run by

companies we don't control, possibly hops across multiple data centers, sometimes across state lines, sometimes across countries, passes through a chain of intermediaries, and only then does it come all the way back into the house to reach her phone. Two devices just a few feet apart. And to me, that just feels wrong. Most of our communication today is controlled by the communication cartels, which are centralized platforms and infrastructure that sit between us and decide how, when, and sometimes if

we can talk. They effectively control our action potential in the digital world. They can shut us off intentionally, as we've seen in real-world crises where communication channels suddenly disappear, or accidentally, like the Verizon outage last month that left millions without service. Now, I'll be honest, when I first looked at Reticulum, I wasn't sold. I mean, the ideas are beautiful, but I've seen a lot of beautiful ideas die in a GitHub

repo. So I went deep. I read the docs. I watched Mark's Unstoppable Networks talk at Chaos Communication Congress, looked at real deployments, FriFunk, MeshNYC, GiphyNet, Meshtastic Communities, and the deeper I went, the more confused I got because the philosophy made sense, but I still couldn't answer one simple question. Does anyone actually use this? Or is it just another beautiful idea? I decided to stop wondering and just build the thing and see if we could put together

our own parallel network. So I started with an R node, a full build from scratch. Now, Mark dropped a guide on his personal blog, unsigned.io, that walks you through the broad strokes. This build uses a T-beam LoRa board, an Adafruit NeoPixel, a small OLED display, and a very serious-looking inspired military antenna. The case is 3D printed and everything runs on open source software. This particular build will sport a LoRa radio so that I can bring it into the mountains

with me, and I mostly used gear that I already had lying around. But I did have to grab a few small parts from Adafruit. And if you want to follow along, I put together a complete builder guide on my website because full transparency, I hit a few walls. Now, before we go any further, I want to address the obvious question. If you've used Meshtastic or MeshCore, this might look familiar. Same LoRa hardware, similar form factor. So what's the difference?

Meshtastic is an incredible project. It treats the radio as the network. Every device talks to nearby devices, messages hop node to node, and everything revolves around that single LoRa transport layer. For lightweight messaging and telemetry, it's hard to beat. Reticulum does something fundamentally different though, because it's not a radio protocol. It's a full networking stack. So radios, Wi-Fi, Ethernet, serial cables. Reticulum treats all these as interchangeable interfaces, which means you can talk to people

who don't have the same hardware as you, because the network lives above the hardware. Which means a single Reticulum network can span an incredibly slow 5-bit per second Morse code key on one end and a fiber optic line on the other. The spec has no physical upper bound in terms of bandwidth. And the protocol is smart about it. It discovers routes, measures link quality, and knows to send large transfers over fast links, not slow ones.

A packet doesn't replicate endlessly across every node. Instead, it follows an established route. So at a high number of hops, overhead scales linearly and not exponentially. That's the core difference. Meshtastic builds a mesh of radios on the same frequency and configuration. Reticulum builds a network that can use radios, but isn't limited by them. The other thing that sets it apart is identity. There are no usernames, no phone numbers, no IP addresses.

Every device generates its own cryptographic identity, and your address on the network is derived from that identity. Encryption isn't bolted on after the fact. It's the foundation. All traffic is encrypted by default, and the origin of messages is obscured by design. Think of it less like traditional networking, and more like how Web3 treats cryptography as a base layer that everything else is built on. And you don't need an R node to try this. You can run Reticulum over Wi-Fi with an app like MeshChat, or bridge multiple interface

types at the same time. Alright, so the R node is built. Now we just need to bring it to life. If you're using a stock-supported board, you can flash the firmware straight from a web flasher, similar to Meshtastic. But because of this custom build, I needed to modify a few things. I used my IDE to tweak the code, compile a build, and flash it to the device. Now, one R node is interesting, but to actually prove what we talked about, we need a pair. So I'm also going to flash a bare LoRa32v3, which, if it looks familiar, that's because

it was running Meshtastic about an hour ago. Same hardware, completely different network. For the client side, there are a few options. You have apps like Sideband, NomadNet, but the one I had the most luck with is a desktop app called MeshChat. So that's what we'll use. So let's start simple. Two devices, both on Wi-Fi. Reticulum discovers the path automatically, and messages go through. Nothing exotic yet, but watch the network visualizer.

You can actually see the route forming in real time. Now let's swap to something more interesting. Same message, but now it's traveling over 915 MHz LoRa. No Wi-Fi, no internet, no infrastructure at all. Just two radios and open spectrum. Now the one I've been waiting for. This is what I teased at the top of the video. One device on LoRa, one device on Wi-Fi. So on my phone here, I have Sideband going. Sideband spins up its own local instance of Reticulum on this device.

This device is connected to the network over Wi-Fi. It doesn't have any LoRa radio or anything like that. It's just connected over the Wi-Fi interface. The other node is a standard R node. This is using a T-beam, and it's only using LoRa as the Reticulum interface. And then the client is MeshChat on my computer here.

And I have a conversation going between these two devices, between the two clients. And so I can show you that real quick. If I send a message from here, I can say, "Let's go." And the light turns on on the R node, and we also see the message show up over here. It's just cool that you can basically bridge dissimilar radios.

That's what I think is so cool about it. Now the magic under the hood is that I have a third node that has both a Wi-Fi interface and a LoRa interface. And that's what makes it possible for a device with only a LoRa radio to talk to a device with only a Wi-Fi 2.4 gigahertz radio. I just think that's super cool, super powerful. Kind of one of the other advantages of Reticulum. Completely different radios, completely different frequencies, and Reticulum bridges them like it's nothing.

That's what a hardware agnostic network stack looks like in practice. Now, full transparency, the software didn't work perfectly out of the box. I had to tweak configs, resolder one connection, and debug quite a bit. So if you want to build one yourself, I documented all of those hard-won insights that aren't obvious until you've already broken something in the builder guide linked below. LoRa is just one pathway, which is exactly what got me thinking. What if the interface wasn't LoRa at all, but something faster, longer range, and already sitting on my desk?

Now up to this point, we've been proving that Reticulum works, sending messages between radios, encryption, decentralized. Cool, but can it power something even bigger? So I did something slightly ridiculous. I installed Reticulum on my Haven nodes and used the Wi-Fi Halow card as the transport layer. And suddenly, we weren't just sending messages between radios, we actually had a long-range IP mesh with a sovereign routing layer on top,

running completely independent of traditional infrastructure. Just two nodes, open spectrum, and a whole lot of math. We have two Haven nodes. They are essentially Raspberry Pis running OpenMANE. So they're basically acting as router boards. But within these configurations, there are Morse Micro Halow cards. Wi-Fi Halow, 802.11a.h. It's also running some other fancy stuff like 802.11s.

So conceptually, we have the blue node, we have the green node. What's interesting and unique about this setup is that on both of these, I've installed Reticulum. So the Linux version of Reticulum, and both of them are running Reticulum. Now with Reticulum, you define interfaces. So these each have traditional Wi-Fi radios. I think they have Bluetooth and other radios on board. But the interface is on the Morse Micro Wi-Fi Halow card,

which I have configured currently at 916 MHz on channel 28. So, and I'm actually, I'm drawing a blank as to what the channel width is on that. So let me check that real quick. So if I go to quick config, all right, so 8 MHz, channel 28. But I could just as easily go over 4, 2, 1, based on if I want to optimize for like range or something. But the cool thing is just we have Reticulum, the interface is Wi-Fi Halow.

Reticulum doesn't really care what the radio is. And what I'm showing you right now is a Python script that I'll throw in this repo. And it's just giving you all the stats. And it's refreshing in real time here. And so basically, they address each other over their unique hashes. It has some metrics about the signal. So like the frequency of the channel. And you can see the signal right there is negative 1 dBm. There's basically no loss.

The antennas are right next to each other. This one's reporting negative 6, but the signal is really good. But I can also prove that this is in fact a live feed. Because if I remove this antenna, we're going to see that signal jump up to, in this case, negative 34. So it actually still gets a signal from conductor to conductor. But it's not as strong without the antenna. But the point is, you can see the metrics respond in real time

as we change the physical configuration. And they're sending data. So you see down here with packets, it's sending data from the green node to the blue node. The blue node is not sending anything back to the green node. That's fine. And so you can set up your interfaces in different ways. But this is using just a UDP interface. What's cool about this is, you know, with Wi-Fi Halow and these OpenMana setups, we're already using WPA3 SAE for the encryption over Wi-Fi.

But once it hits the device, that encryption terminates and you get plain text. Reticulum is more like cryptographically complete. Like you have to have a hash. Each entity signs with each other. And so everything is a little bit more private. Like you also can't tell the origin of different nodes because it doesn't get passed in the header information, unlike TCP/IP where it does. But what's more interesting to me than just like the privacy centricity of it is

the fact that it can bridge interfaces. Like I think when the guy was coming up with this Reticulum project, I don't think like Halow was really that popular. I'm not even sure if he had Halow on his radar. And yet it works fine with Halow because it's agnostic to the radio. And what's really powerful is you could have another interface on the same Reticulum node that runs over something like Wi-Fi 2.4, Wi-Fi 5 GHz.

And then suddenly a Wi-Fi 5 GHz enabled device can talk to a Wi-Fi Halow device, as long as there's a bridge somewhere. And all that bridging happens automatically. And then Reticulum just scales up linearly, not exponentially, because it doesn't flood and repeat packets everywhere. So lots of kind of tailwinds in terms of how this project works. It's designed to scale. It's designed to be autonomous. It's designed to be interoperable, secure, and it's all open source. And so I just think this is pretty exciting.

If things continue to work as I've been observing them working, Reticulum is going to be a part of standard operating procedure for Haven. I've already added it to the guide with information. A lot of scripts that took a lot of troubleshooting to get working are going to be up on GitHub. So feel free to check those out. And there's a lot more kind of meat on the bone here in terms of exploring the art of what's possible. So if anyone kind of does anything wild, exotic, crazy,

definitely let me know about it. I'd be interested. So anyways, that is Reticulum data going from Haven node to Haven node. And then I tried something that I really didn't think was going to work. I ran ATAC over it. And then for those of you who don't know, ATAC is Android Tactical Awareness Kit. It's a mapping tool that's good for like search and rescue, small units in off-grid situations, has a bunch of networking capabilities under the hood.

It's fully open source. And it was originally released by I think like the Department of Defense. So pretty powerful in use in the military and used domestically with different like governmental agencies and things like that. So lots of interest in this project. Okay. And so this is the final example that I have. So again, two Haven nodes, which are running OpenMana, which is essentially OpenWrt. It's running on Raspberry Pi hardware. And they are connected, they're bridged only by a Morse micro Wi-Fi Halow 80211AH

Wi-Fi chip. And specifically, it's going over the 915 megahertz frequency. I have ATAC running on two end-user devices here. So two Android devices. This guy is connected to this guy's 2.4 Wi-Fi. So that would kind of go there logically. And then this guy is connected to the green's either 2.4 or 5 gigahertz Wi-Fi.

I'm not really sure, but these are on those networks like that. And they can see each other. So if I like go to chat or if I go to the map or something, I can see the other device. But what's interesting about this is the data is actually flowing over Reticulum. And Reticulum is using the Halow card as its interface. And so on these computers, I have a script running.

I'm just going to get it going on this one. That is essentially logging the data that's being sent across the devices. So on these, we can see some details about the frequency and the RSSI. But we can also see the occasional cursor on target data that gets sent back and forth. And you'll see that like every few seconds. But if I send a message.

So I'm going to say, can you hear me now? Question mark. OK, so now we see the message. It doesn't say cursor on target. It says chat. And we see it over here as well. It was compressed and it was chunked into two different fragments. And then it was sent. So we see that show up on both of the SSH logs here.

And I should have mentioned this computer is connected to this guy's OpenMana Lucy interface. This computer is connected to this guy's OpenMana Lucy interface. And they're both running the same log. They're just tailing the log. And that log is designed to give details about the Reticulum data transfer. So COT and SA or chat data, the way these work out of the box is sent over multicast,

which has a certain IP address and a certain port and all that stuff. We just run a Reticulum bridge Python script that kind of hijacks that and then sends it over Reticulum. To get that to work, you just run this Python script on both of these devices. You typically start it on one. It'll generate a hash. And then you start it on the other, but you'll provide an argument of that hash. But yeah, so data can flow over Reticulum, which is really cool. But it can also flow over Reticulum using the Wi-Fi Halow interface.

So these can go long range. I'm using the 8 megahertz channel right now, but you could bring that down to 1 megahertz. And you can get quite a bit of distance. Would you want to use Reticulum for something like this? Potentially. These Wi-Fi networks are using WPA3 SAE, but Reticulum does a whole lot of other cool, interesting things beyond just the kind of cryptography centricity that it brings to communications.

It also brings the autonomous networking, and it brings the bridging of disparate radio modulation techniques, which is incredibly cool. So for instance, these are talking over Halow. Cool. But Reticulum on this could actually bridge all the Wi-Fi radios. And you can actually end up in a network topology where a device that only has, say, for instance, a LoRa radio can talk to a device that has, for instance,

only traditional Wi-Fi, which is cool. It's something that we haven't really seen before. Usually these mesh networks are pretty rigid about staying on the same frequency channel and all that stuff. And Reticulum just is more agnostic towards the actual radio, focuses on the network part, which makes it super powerful. So, yep, Reticulum with ATAC, it works. We're sending messages. Potentially could do other cool things like voice and all that. But I'm going to throw this code all up on GitHub, so you guys can run it yourself if you want.

And yeah, I'm pretty impressed with this. So I did not think that was going to work. And it just, I don't know, it just feels powerful. Like you're doing, I'm doing all this stuff. Like I could give this to, you know, search and rescue team and give this to another team or on camp or farm or what have you. And, you know, that you can be communicating. And it's private, it's secure, it's powerful. It's using pretty slick tech, both on the software and the hardware front. So overall, very, very impressed with what this stuff can do.

And if Reticulum continues to deliver, and I have no major hurdles, it's definitely going to be part of the Parallel Tech stack. Now, ATAC normally expects Wi-Fi or cellular, basically a traditional network stack, infrastructure, etc. But underneath, Reticulum is routing cursor-on-target traffic across Halow radios, compressing it, fragmenting it to fit within Reticulum's 500-byte MTU, and reassembling it on the other side. Encrypted end-to-end.

A fully open-source, decentralized, cryptographically complete tactical networking stack. Which I'm sure is going to earn me another email from the Department of Defense. But honestly, this does blow my mind. Because moments like this are why I started building in the first place. And I couldn't be here without you. Not as an audience, but as people building this alongside me. Because every experiment, every comment, every person quietly following along, and then showing up in the Discord with something they built, it really pushes us one step closer to something bigger.

A parallel network we don't rent, we actually own. Now all the details about getting Reticulum running on the Haven node, and then creating that bridge that ATAC can make use of, is all going to be open-sourced and on a GitHub repo, which you can find in the description below. Now before I go, I want to leave you with something you've probably never seen before. So for the R node that we built, I actually ordered a few different faces, using different composites from 3D printing companies on JLC3DP and CraftCloud.

And with that, I may have gone a little bit overboard. This is the R node faceplate, except it's printed in TC4 titanium, which is aerospace grade. It's stronger than steel at half the weight. I know, completely unnecessary, which is exactly why I love it. Because if building infrastructure doesn't depend on anyone's permission, it might as well look like it belongs on a spacecraft. And if you want to get caught up on the latest in the off-grid IP mesh radio space, check out this next video.