MeshCore

I have previously written about Meshtastic, a LoRa-based communication system that is starting to make off-grid messaging remarkably accessible. You can take a small, inexpensive device, connect it to your phone, and suddenly have a radio-based messaging system without any mobile network or Internet connection. It is difficult not to be intrigued by that.

Recently, I also started experimenting with another LoRa mesh technology: MeshCore. At first glance, MeshCore can look very similar to Meshtastic. It uses LoRa, runs on many of the same types of inexpensive hardware, and provides off-grid communication over surprisingly long distances. But underneath, the two systems take quite different approaches. And coming from a networking background, that difference is what makes MeshCore particularly interesting to me.

One of the things I like about Meshtastic is how easy it is to get started. Flash the firmware, connect the device to your phone, and you are essentially ready to go. Depending on where you are, you may quickly discover other nodes, see their positions on a map, exchange messages and get a very tangible feeling that you have suddenly become part of a larger radio network. There is a definite “wow factor” to this.

My first impression of MeshCore was quite different. The network can initially appear much quieter. There may be relatively few visible nodes, and it is not necessarily immediately obvious how much infrastructure exists behind the network.

But that is partly because the two systems have fundamentally different ideas about how a mesh network should be built. With Meshtastic, participating nodes can also act as routers and relay traffic for other nodes. MeshCore makes a much clearer distinction between clients and network infrastructure. A typical MeshCore network consists of client devices communicating through dedicated repeaters.

Client ─── Repeater ─── Repeater ─── Client
              │
              │
           Repeater
              │
           Client

The repeater is therefore not simply another user’s device that happens to forward packets. It is part of the network infrastructure. This is a familiar concept from traditional computer networking. You don’t normally expect every laptop connected to an Ethernet network to become a router. Instead, you build a network from endpoints and dedicated infrastructure.

Why does this matter? LoRa has limited bandwidth and radio airtime is a finite resource. As the number of participating nodes increases, contention and unnecessary retransmissions can become increasingly important. A network where forwarding infrastructure is deliberately deployed and managed is fundamentally different from one where every node can participate in forwarding traffic.

I don’t think this necessarily means that MeshCore is “better” than Meshtastic. They are solving somewhat different problems. Meshtastic is extremely good at making a mesh network accessible. MeshCore is interesting because it makes me think about how that network could scale.

I have not (yet) deployed my own MeshCore repeater. Instead, I am currently experimenting with a SenseCAP device configured as a MeshCore client. Fortunately, my location gives me a very good opportunity to test this. I have line-of-sight to an existing MeshCore repeater on Rundemanen, a mountain overlooking Bergen, roughly 7 km away. That means I can experiment with MeshCore without having to build the infrastructure myself.

So far, my experience has been interesting. Compared with Meshtastic, the MeshCore network around me initially appears surprisingly sparse. With Meshtastic, it is quite easy to open the app and quickly discover a collection of nodes. MeshCore feels much more infrastructure-oriented. The repeaters are the important part of the network, while individual client devices are not necessarily as visible. That difference can initially make MeshCore feel less impressive.

But the more I think about it, the more I understand the idea behind it.

MeshCore feels like networking. I have worked with computer networks for many years, and this is probably why MeshCore caught my attention. Meshtastic feels a little like discovering a new radio world. MeshCore feels more like building a network. The distinction between endpoints and infrastructure is something I immediately recognise from conventional networking.

You can deliberately place repeaters where they provide useful coverage and build links between strategically located sites. You can think about topology, coverage and capacity instead of simply having every participating device contribute to the mesh. A few dozen devices scattered around a neighbourhood is one thing. A network covering an entire region is something very different.

Another interesting part of MeshCore is how routing works. Instead of requiring the network to know the complete route between every pair of devices in advance, MeshCore can initially use flooding to discover a path through the repeater network. Once a route has been discovered, the system can make use of that information for subsequent communication. In other words, the network can learn how to reach a destination instead of treating every message as if it were the first message ever sent.

This is another area where the design starts to feel much more like conventional networking. The goal is not simply to make one packet reach the other side, but to create a network that can efficiently continue communicating once a path has been established.

Meshtastic has the immediate “wow” factor, at least in my experience. You install it, connect your phone, and the network can feel alive almost immediately. MeshCore is more subtle. You start to notice the infrastructure and think about how those repeaters could be connected. You start wondering what happens if there are ten of them, then fifty, then hundreds.

Could this scale into a much larger network? This is probably the question I find most interesting. What would a national LoRa-based communication network look like if it were designed from the beginning with separate infrastructure and clients? Imagine strategically placed repeaters on mountains, towers and other high locations. The repeaters could form a regional and eventually national backbone, while ordinary users would simply connect as clients.

Something like this:

                    NATIONAL BACKBONE

             ┌──────── Repeater ────────┐
             │                            │
        Repeater ───── Repeater ───── Repeater
             │                            │
             │                            │
        ┌────┴────┐                 ┌────┴────┐
      Clients   Clients           Clients   Clients
      Meshtastic                     Meshtastic

The really interesting part would be separating the backbone technology from the user experience. A user shouldn’t necessarily need to know how the backbone works. They could simply open an app, see nearby users, send a message and perhaps see a map of the network. Underneath, the infrastructure could use a more structured and scalable architecture.

Could MeshCore somehow be the backbone for Meshtastic? This is where things get particularly speculative. MeshCore and Meshtastic are different protocols. A MeshCore repeater cannot simply become a Meshtastic repeater, and the two networks do not natively form one combined mesh. However, it is interesting to imagine a gateway between the two worlds.

For example, a regional network could have MeshCore repeaters providing the long-distance infrastructure, while gateways connect local Meshtastic networks to that infrastructure. Conceptually, it could look something like this:

 Meshtastic                    MeshCore Backbone

 [Client]                        [Repeater]
     │                               │
 [Local Mesh] ── Gateway ───── [Repeater] ─── [Repeater]
     │                               │
 [Client]                        [Repeater]
                                     │
                                  Gateway
                                     │
                               [Local Mesh]
                               Meshtastic

This would not be MeshCore simply replacing Meshtastic. It would be a multi-layer network, where different technologies are used for different parts of the system. Whether such an architecture would actually be practical is another question. Radio spectrum, airtime, interference, hardware costs, routing, gateway design and regulatory requirements would all become important.

But from a networking perspective, the concept is fascinating.

For me, this isn’t really an either/or question. Meshtastic is incredibly approachable, with a very low barrier to entry and an immediate sense of being connected to a larger network. MeshCore takes a more infrastructure-oriented approach.

If I just want to hand someone a small LoRa device and say “connect your phone and start experimenting”, Meshtastic has a very compelling user experience. If I start thinking about how thousands of devices could potentially share a geographically distributed network, the architecture becomes much more interesting.

And that is probably the biggest difference in my mind.

Meshtastic makes me want to use the network.

MeshCore makes me want to build the network.

I don’t think MeshCore and Meshtastic should necessarily be viewed as competing technologies. They demonstrate two different approaches to solving a similar fundamental problem: how can inexpensive LoRa radios be turned into useful communication networks without relying on traditional infrastructure?

Meshtastic has shown how accessible this can be. MeshCore has made me think more about what happens when the network grows.

Could we eventually have large-scale, perhaps even national, LoRa communication networks where carefully designed backbone infrastructure provides the connectivity, while users get a simple and intuitive experience at the edge?

I don’t know.

But as someone with a background in networking, that is the part of MeshCore I find most exciting. The hardware is inexpensive, the radio technology is already available, and the software is open source. There are already people experimenting with repeaters and larger networks.

Perhaps the most interesting thing is not whether MeshCore will replace Meshtastic.

Perhaps it is what we can build when we stop thinking of these devices as individual radios and start thinking of them as network infrastructure.