Skip to content

Data Slayer Networking Hardware Security Homelab

The Internet, Reinvented.

Data Slayer argues the internet is not cables or towers but routing, and rebuilds it with Reticulum, a cryptography first networking stack that treats every radio as an interchangeable interface. He hand builds an RNode, then bridges a LoRa only device to a Wi-Fi only device through a dual interface node, proving mismatched hardware can share one network. Scaling up, he runs Reticulum over a long range Wi-Fi HaLow IP mesh on two Raspberry Pi Haven nodes with encryption and route based scaling. The finale routes the Department of Defense mapping app ATAK across that homemade network by hijacking its multicast traffic and fragmenting it to a 500 byte MTU. A build log for a parallel network you own instead of rent.

Published Feb 22, 2026 23:30 video 23 min read Added Jul 7, 2026 Open on YouTube →

At a glance

Two little radios sit on the bench. One speaks LoRa at 915 megahertz, a slow long range signal with no Wi-Fi anywhere in it. The other speaks ordinary 2.4 gigahertz Wi-Fi with no long range radio at all. Different frequencies, different modulation, different silicon. By every rule of how mesh radios normally work, they cannot exchange a single byte. And then they do. Data Slayer opens the video on exactly that impossible handshake, and spends the next twenty three minutes explaining the one idea that makes it possible: the internet is not cables or towers, it is just routing, and once you accept that, you can rebuild it out of whatever radios you happen to own.

The tool that pulls it off is Reticulum, a cryptography first networking stack that some people call "the hacker network." It is not a radio protocol like Meshtastic. It is a full network layer that treats every physical medium, a 5 bit per second Morse key, a LoRa link, Wi-Fi, Wi-Fi HaLow, Ethernet, serial cable, or fiber, as an interchangeable interface. The video is a build log and an escalating set of live demos: a hand soldered RNode, then two radios bridged across mismatched hardware, then Reticulum running over a long range HaLow IP mesh on a pair of Raspberry Pi "Haven" nodes, and finally the Department of Defense mapping app ATAK routing its tactical traffic across that homemade sovereign network. This page rebuilds the whole thing in order, with every board, frequency, number, and gotcha he put on screen.

The cold open: two radios that should not understand each other

The hook is a magic trick with the reveal withheld. One device runs a long range 915 megahertz radio and no Wi-Fi. The other runs Wi-Fi and no long range radio. They share no modulation technique, no radio hardware, and not even the same frequency band, so they "definitely shouldn't understand each other." Then a message crosses between them anyway. Data Slayer freezes on the contradiction and states the thesis that resolves it: what we call the internet "isn't actually cables or towers, it's just routing." Accept that one sentence and, in his words, "some very strange things become possible." He promises that by the end he will show the strangest rig he has ever built, one he is "still shocked actually worked," but first he has to explain the idea underneath.

He has spent years on this beat: covering decentralized radio tech, building nodes, breaking things, testing systems most people never see. Across the comments, the forums, and his DMs, one name kept surfacing, a project he had "mostly ignored," Reticulum. People call it the hacker network, he clarifies, not because it is illegal but because it embodies a different philosophy of communication: open, autonomous, and sovereign, needing no permission and no centralized infrastructure. Rather than keep talking about it, he decided to build one and find out whether the philosophy survives contact with the real world.

The thesis: why we need a parallel network at all

The problem statement is domestic and a little absurd. Our devices are capable, diverse, and always changing, yet the moment they try to talk, the data has to flow through remote infrastructure owned by other people. His example: he wants to message Amelia, who is "literally downstairs in the same house." The packet does not hop the few feet between the two phones. It leaves the home network, travels out to remote infrastructure run by companies he does not control, possibly bounces across multiple data centers, sometimes across state lines, sometimes across national borders, passes through a chain of intermediaries, and only then loops all the way back into the house to land on her phone. Two devices a few feet apart, one absurd round trip. "To me, that just feels wrong."

Figure 1. The message to Amelia. Two phones a dozen feet apart, and the packet still leaves the house, crosses infrastructure and borders owned by other people, and comes all the way back. Reticulum exists to delete that detour.

He gives the detour a name: the "communication cartels." These are the centralized platforms and infrastructure that sit between us and decide how, when, and sometimes whether we can talk. They "control our action potential in the digital world," and they can cut it off two ways. Intentionally, as in real world crises where communication channels suddenly vanish. Or accidentally, "like the Verizon outage last month that left millions without service." A network you rent can be switched off. A network you own cannot.

Meeting Reticulum, and the doubt

He is careful not to arrive as a believer. "When I first looked at Reticulum, I wasn't sold." The ideas are beautiful, but he has "seen a lot of beautiful ideas die in a GitHub repo." So he went deep: read the docs, watched creator Mark Qvist's "Unstoppable Networks" talk from the Chaos Communication Congress, and studied real deployments, naming community networks like Fry Funk, Meshen NYC, Gyet, and various Meshtastic communities. The deeper he went, the more one plain question nagged at him: does anyone actually use this, or is it one more gorgeous idea nobody runs? He stopped wondering and decided to build the thing himself, to see whether he could stand up his own parallel network.

Building the RNode from scratch

The first build is a full RNode from parts. Mark posted a broad strokes guide on his blog, unsigned.io, and Data Slayer follows it with a LILYGO T-Beam LoRa board, an Adafruit NeoPixel, a small OLED display, and a "very serious looking" military inspired antenna. The enclosure is 3D printed and everything runs on open source software. He specs this unit with a LoRa radio on purpose so he can carry it into the mountains, and he mostly reuses gear he already had, grabbing only a few small parts from Adafruit. Full transparency, he says: he "hit a few walls," so he wrote his own complete builder guide to capture the parts that are not obvious.

Reticulum is not Meshtastic

Anyone who has touched Meshtastic or MeshCore will see the same LoRa hardware and similar form factor and ask what the difference is. He answers it squarely. Meshtastic is an incredible project, and it "treats the radio as the network." Every device talks to nearby devices, messages hop node to node, and everything revolves around a single LoRa transport layer. For lightweight messaging and telemetry, it is hard to beat.

Reticulum is doing something fundamentally different because it is not a radio protocol at all, it is a full networking stack. Radios, Wi-Fi, Ethernet, and serial cables are all just interchangeable interfaces to it, because "the network lives above the hardware." That is why 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 on bandwidth, and the protocol is smart about the spread: it discovers routes, measures link quality, and knows to send large transfers over the fast links rather than the slow ones. Crucially, a packet does not replicate endlessly across every node. It follows an established route, so as hop counts climb the overhead "scales linearly and not exponentially." That is the core difference in one line: Meshtastic builds a mesh of radios locked to one frequency and configuration, while Reticulum builds a network that can use radios but is never limited by them.

Question	Meshtastic	Reticulum
What is it	A LoRa radio mesh	A full networking stack, above the radio
Transport	One LoRa layer, one frequency and config	Any interface: LoRa, Wi-Fi, HaLow, Ethernet, serial, fiber
Talk across different hardware	No, everyone shares the radio	Yes, 5 bit per second Morse key to fiber on one net
Addressing	Node ids on the mesh	Cryptographic identity, no usernames or IP
Encryption	Layered on the messaging	The foundation, on by default, origin obscured
Scaling with hops	Flood and repeat across nodes	Follows a route, overhead grows linearly
Best at	Lightweight messaging and telemetry	Bridging dissimilar radios into one sovereign net

Figure 2. The distinction he draws on screen. Both run on the same LoRa boards, but one is a radio mesh locked to a frequency and the other is a hardware agnostic network layer that rides anything.

Identity and encryption as the floor, not the frosting

The second thing that sets Reticulum apart is identity. There are no usernames, no phone numbers, and no IP addresses. Every device generates its own cryptographic identity, and your address on the network is derived from that identity. Encryption is not bolted on after the fact, it is the foundation: all traffic is encrypted by default and the origin of a message is obscured by design. He reaches for a familiar analogy, saying to 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 do not even need an RNode to try it. You can run Reticulum over Wi-Fi with an app like Mesh Chat, or bridge several interface types at once.

Figure 3. The hardware agnostic stack. Any physical medium plugs into the same Reticulum layer, so an app never has to know whether it is riding a Morse key or a fiber line. This is the whole reason a LoRa only device can reach a Wi-Fi only device.

Bringing it to life: flashing and choosing a client

The RNode is built, now it has to boot. For a stock supported board you can flash the firmware straight from a web flasher, much like Meshtastic. Because his is a custom build, he had to modify a few things: he opens his IDE, tweaks the code, compiles a build, and flashes the device by hand. One node alone is interesting, but proving the thesis needs a pair, so he also flashes a bare Heltec LoRa 32 V3, noting with a grin that the very same board "was running Meshtastic about an hour ago." Same hardware, completely different network. On the client side he lists the options, Sideband and Nomad Net, but the one he had the most luck with is the desktop app Mesh Chat, so that is what the demos use.

The demo ladder: four steps, each stranger than the last

He does not jump to the finale. He climbs to it, and each rung removes a piece of the traditional internet.

Demo 1 Two devices, both on Wi-Fi. Reticulum discovers the path automatically and the messages go through. Nothing exotic yet, but watch the network visualizer: you can see the route form in real time.
Demo 2 The same message, now traveling over 915 megahertz LoRa. No Wi-Fi, no internet, no infrastructure at all. Just two radios and open spectrum.
Demo 3 The one he teased at the top. One device on LoRa, one device on Wi-Fi. His phone runs Sideband over Wi-Fi with no LoRa radio in it. The other node is a T-Beam RNode using only LoRa. They talk anyway, because a third node carries both a Wi-Fi and a LoRa interface and bridges them automatically.
Demo 4 Reticulum on a pair of long range Haven nodes over Wi-Fi HaLow, then the ATAK tactical mapping app routed on top of it. The internet, gone entirely, the app none the wiser.

Figure 4. The escalation. Each demo strips out one more assumption, from "both on Wi-Fi" down to "no traditional network anywhere," ending on a defense grade app that never notices.

On Demo 3 he narrates the rig from his own mouth. On the phone, Sideband "spins up its own local instance of Reticulum" and connects over the Wi-Fi interface only, with no LoRa radio present. The other node is a standard RNode on a T-Beam using LoRa as its sole Reticulum interface, and the client watching the conversation is Mesh Chat on his computer. He types "let's go," the NeoPixel light flicks on over on the RNode, and the message appears on the other client. "It's just cool that you can basically bridge dissimilar radios." The magic under the hood, he explains, is that third node holding both a Wi-Fi and a LoRa interface, which is what lets a LoRa only device reach a Wi-Fi only 2.4 gigahertz device. "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."

He keeps the honesty valve open. The software "didn't work perfectly out of the box." He had to tweak configs, resolder one connection, and debug quite a bit, and he says he documented all those hard won insights, "the ones that aren't obvious until you've already broken something," in the builder guide.

Going bigger: Reticulum over a long range HaLow IP mesh

LoRa was only ever one pathway, which got him thinking. What if the interface were not LoRa at all, but something faster, longer range, and already sitting on his desk? So he did "something slightly ridiculous." He installed Reticulum on his Haven nodes and used their Wi-Fi HaLow card as the transport layer. Suddenly he was not merely sending messages between radios. He 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."

The hardware: two Haven nodes, essentially Raspberry Pis running OpenMANET, which he describes as "essentially OpenWRT," acting as router boards. Inside each is a Morse Micro Wi-Fi HaLow card, 802.11ah, and it is also running "fancy stuff" like 802.11s mesh. He labels them the blue node and the green node, and the unusual part is that both run the Linux build of Reticulum. In Reticulum you define interfaces, and although each Pi has traditional Wi-Fi, Bluetooth, and other radios on board, the interface he binds is the Morse Micro HaLow card, "configured currently at 916 megahertz on channel 28." He checks the channel width live in quick config: 8 megahertz on channel 28, though he notes he could just as easily drop to 4, 2, or 1 megahertz to optimize for range instead of throughput. The point stands: the interface is Wi-Fi HaLow, and "Reticulum doesn't really care what the radio is."

He then shows a Python stats script he says he will drop in the repo, refreshing in real time. The nodes "address each other over their unique hashes," and the readout carries live metrics: the channel frequency, and a signal reading of about minus 1 dBm, essentially no loss, because the antennas are right next to each other, with the other side reporting around minus 6. To prove it is a genuine live feed and not a fake dashboard, he yanks an antenna off and the signal degrades to roughly minus 34, still passing conductor to conductor but far weaker. The metrics move as he changes the physical setup, and packets are flowing from the green node to the blue node, with the blue node not replying, which is fine. This particular link runs over a plain UDP interface.

WPA3 versus being cryptographically complete

This is where he sharpens the security argument, and it is subtler than "it is encrypted." With Wi-Fi HaLow and these OpenMANET setups he is already using WPA3 SAE to encrypt the link over the air. But that protection covers the hop only. "Once it hits the device, that encryption terminates and you get plain text." Reticulum, by contrast, is "cryptographically complete." You have to have a hash, each entity signs with the others, and everything is more private end to end. You also cannot tell the origin of a given node, because the source is not carried in the header the way it is in TCP/IP.

What excites him more than the privacy, though, is the bridging. He points out that when Mark first designed Reticulum, HaLow was probably not popular, and "I'm not even sure if he had HaLow on his radar," yet it works fine with HaLow because the stack is agnostic to the radio. Better still, you can add a second interface to the same Reticulum node running over Wi-Fi 2.4 or 5 gigahertz, and then a 5 gigahertz Wi-Fi device can reach a HaLow device as long as a bridge exists somewhere, and all that bridging happens automatically. And because Reticulum follows routes instead of flooding and repeating packets everywhere, it scales up linearly rather than exponentially. His summary of the tailwinds: it is designed to scale, to be autonomous, to be interoperable, to be secure, and it is all open source. If it keeps working the way he has watched it work, Reticulum "is going to be part of standard operating procedure for Haven," and the troubleshot scripts are headed to GitHub.

The final rig: ATAK riding on Reticulum

Then he tried the thing he genuinely did not expect to work: he ran ATAK over it. For the uninitiated, ATAK is the Android Team Awareness Kit, a mapping tool built for search and rescue and small units in off grid situations, with a lot of networking capability under the hood. It is fully open source and was originally released by, he believes, the Department of Defense, and it is used in the military, domestically, and by various government agencies.

The setup mirrors the HaLow mesh. Two Haven nodes running OpenMANET on Raspberry Pi hardware, bridged only by a Morse Micro Wi-Fi HaLow 802.11ah chip over 915 megahertz. ATAK runs on two Android end user devices. One Android is joined to one node's 2.4 gigahertz Wi-Fi, the other Android to the green node's 2.4 or 5 gigahertz Wi-Fi. The two apps can see each other, on the chat and on the map, but the data underneath is actually flowing over Reticulum, and Reticulum is using the HaLow card as its interface.

On each computer he runs a logging script, tailing the OpenWRT Luci interface of its node, and the logs show frequency, RSSI, and the occasional Cursor on Target message that ATAK emits every few seconds. He types "can you hear me now?" and the message appears on both ends. In the log it is tagged as chat rather than cursor on target, and, tellingly, it was "compressed and chunked into two different fragments and then sent," visible in both SSH logs. The mechanism: ATAK's cursor on target and situational awareness data is sent over multicast on a fixed IP and port out of the box, and a "Reticulum bridge Python script kind of hijacks that and then sends it over Reticulum." You run the script on both devices, start it on one where it generates a hash, then start it on the other with that hash as an argument.

Figure 5. How a Department of Defense app rides a homemade radio net. ATAK still thinks it is on ordinary multicast, while a Reticulum bridge captures its Cursor on Target traffic, compresses and fragments it to the 500 byte MTU, carries it over HaLow, and reassembles it on the far node.

He steps back to say why the fragmentation matters. ATAK normally expects Wi-Fi or cellular, a traditional network stack. 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. In his words it is "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." He could hand one node to a search and rescue team and another to a second team, on a camp or a farm, and they would have communication that is private, secure, and powerful on both the software and hardware fronts. If Reticulum keeps delivering with no major hurdles, "it's definitely going to be part of the parallel tech stack." He credits the community directly, the people who show up in the Discord with something they built, for pushing toward "a parallel network we don't rent, we actually own," and promises the Haven plus ATAK bridge scripts will be open sourced on GitHub.

One more thing: the titanium face plate

He closes on a flourish. For the RNode he built, he ordered a few different faces in different composites from 3D printing services JLC3DP and Craftcloud, and admits he "may have gone a little bit overboard." The showpiece is the RNode face plate printed in TC4 titanium, aerospace grade, "stronger than steel at half the weight." Completely unnecessary, which is exactly why he loves it: "if building infrastructure doesn't depend on anyone's permission, it might as well look like it belongs on a spacecraft." He signs off pointing to more in the off grid IP mesh radio space.

Key takeaways

The internet is routing, not wires. Once you treat "the internet" as a routing problem rather than specific cables or towers, you can rebuild connectivity out of whatever radios you own.
Reticulum is a network layer, not a radio protocol. That single distinction from Meshtastic is the whole video. The network lives above the hardware, so LoRa, Wi-Fi, HaLow, Ethernet, serial, and fiber are all just interfaces.
Mismatched radios can talk if a bridge exists. A LoRa only device reaches a Wi-Fi only device through any node that holds both interfaces, and Reticulum handles the bridging automatically.
Encryption and identity are the floor. No usernames, phone numbers, or IP addresses. Every device has a cryptographic identity, traffic is encrypted by default, and origins are obscured, which he contrasts with WPA3 that protects only the single hop.
It scales linearly, not exponentially, because packets follow discovered routes instead of flooding every node.
It runs real apps. A Department of Defense mapping tool, ATAK, ran unmodified on top by hijacking its multicast traffic and fragmenting it to a 500 byte MTU.
This is a build log, not a lecture. Custom RNode, tweaked firmware, resoldered joints, live signal proofs, and honest "it did not work out of the box" moments throughout.

Where it stands

For the honest footnote near the end: Reticulum is a real, actively maintained, open source project by Mark Qvist, and everything demonstrated here is a genuine capability of the stack, not a mockup. The bridging of dissimilar radios, the cryptographic identity model, and route based scaling are documented properties, not marketing. Two honest calibrations. First, the demos are bench proofs with antennas inches apart and one directional UDP traffic, so they show that the routing works, not that a kilometer scale deployment performs a given way. Second, "communication cartels," "sovereign," and "a network we own" are Data Slayer's framing, and he has skin in the game: Data Slayer is the media arm of Parallel, which sells the Haven nodes and the build guides he links, so the enthusiasm is real and also commercial. None of that undercuts the core result, which is genuinely striking: a hand built radio net carried an unmodified defense grade app end to end with no traditional infrastructure in the path. The "email from the Department of Defense" line is a joke, but the technical claim under it is not.

Chapters

00:00 The impossible handshake, two radios that should not talk 01:05 Reticulum, the network people call the hacker net 01:31 Why we need this, the message to Amelia downstairs 02:28 The communication cartels and the Verizon outage 03:35 Building an RNode from scratch 04:30 Reticulum versus Meshtastic and MeshCore 05:53 Identity and encryption as the foundation 06:40 Flashing firmware and choosing a client 07:21 Demo 1, two nodes over Wi-Fi 07:38 Demo 2, the same message over 915 MHz LoRa 08:38 Demo 3, bridging LoRa and Wi-Fi, the teased rig 10:18 Reticulum on Haven nodes over Wi-Fi HaLow 11:01 Reading the live link, blue node and green node 13:27 WPA3 versus cryptographic completeness 15:40 Running ATAK over Reticulum 16:17 The final rig, ATAK across two Haven nodes 21:48 Under the hood, fragmenting to a 500 byte MTU 22:35 A parallel network we own 23:00 One more thing, the titanium face plate

Notable quotes

"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." (00:26)
"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." (01:07)
"Two devices just a few feet apart. And to me, that just feels wrong." (01:52)
"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." (02:20)
"The ideas are beautiful, but I've seen a lot of beautiful ideas die in a GitHub repo." (02:56)
"It's not a radio protocol. It's a full networking stack." (04:50)
"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." (05:10)
"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." (09:40)
"Reticulum doesn't really care what the radio is." (11:44)
"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." (21:55)
"A parallel network we don't rent, we actually own." (22:33)
"If building infrastructure doesn't depend on anyone's permission, it might as well look like it belongs on a spacecraft." (23:20)

Resources mentioned

Reticulum and the Reticulum source on GitHub, the cryptography first networking stack at the center of the video.
Mark Qvist and unsigned.io, Reticulum's creator and the blog that hosts the original RNode guide.
Mark's "Unstoppable Networks" talk archive at the Chaos Communication Congress.
RNode firmware, the open radio node firmware flashed onto the boards.
Meshtastic and MeshCore, the LoRa mesh projects he contrasts against Reticulum.
Sideband, Nomad Net, and Reticulum Mesh Chat, the Reticulum client apps.
LILYGO T-Beam and Heltec LoRa 32 V3, the LoRa boards used for the RNodes.
Adafruit NeoPixel, the addressable LED on the build.
Morse Micro and Wi-Fi HaLow, 802.11ah, the sub gigahertz Wi-Fi used for the long range IP mesh.
802.11s and BATMAN mesh routing and OpenWRT, the router foundation of the Haven nodes.
WPA3 SAE, the link layer encryption he compares to Reticulum's end to end model.
ATAK, the Android Team Awareness Kit, and TAK, plus Cursor on Target, the tactical app and message format bridged over Reticulum.
JLC3DP and Craftcloud, the 3D printing services for the RNode faces, including the TC4 titanium plate.
Parallel, Data Slayer's project, with the Haven IP mesh radio guide and the RNode build guide.
Data Slayer on YouTube and on X.

Full transcript

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 everchanging. 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: Fry Funk, Meshen NYC, Gyet, 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 use 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 Mesh Core, 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 web 3 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 Mesh Chat or bridge multiple interface types at the same time. All right, 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 use 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 LoRa 32 V3, 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, Nomad Net, but the one I had the most luck with is a desktop app called Mesh Chat. 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 megahertz 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 um 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 Mesh Chat 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 GHz 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 OpenMANET. So they're basically acting as router boards. But within these configurations there are Morse Micro HaLow cards, Wi-Fi HaLow 802.11ah. 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 like 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 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, you know, if I want to optimize for 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. 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 -1 dBm. There's basically no loss. The antennas are right next to each other. This one's reporting -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 -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's 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 OpenMANET 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 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 or 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 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 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 meat on the bone here in terms of exploring the art of what's possible. So if anyone 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 ATAK over it. For those of you who don't know, ATAK 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, in use domestically with different 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 OpenMANET 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 802.11ah Wi-Fi chip and specifically it's going over the 915 MHz frequency. I have ATAK 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 GHz Wi-Fi. I'm not really sure, but these are on those networks like that. And they can see each other. So, if I 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. Okay 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 OpenMANET Luci interface. This computer is connected to this guy's OpenMANET Luci 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 MHz channel right now, but you could bring that down to 1 MHz 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 like 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 ATAK, 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, did not think that was going to work. And it just, I don't know, it just feels powerful. Like I'm doing all this stuff, I could give this to a search and rescue team and give this to another team 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 ATAK 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, then creating that bridge that ATAK 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 JLC 3DP and CraftCloud. And with that, I may have gone a little bit overboard. This is the R node face plate, except it's printed in TC4 titanium, which is aerospace grade. 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.