LPWAN Meshes: MeshCore - Moving Beyond the Ad-Hoc

While Meshtastic serves as a solid introduction to LPWAN mesh networking, MeshCore represents a move toward more structured networks, particularly when the limits of ad-hoc flooding become a bottleneck. It addresses the “airtime” congestion common in simpler protocols, offering a far more robust path for community-scale infrastructure where a “best effort” approach isn’t enough. MeshCore is built for managed deployments and regional sensor networks where reliability and structured routing are the priority.

I’ll be honest: MeshCore has a steeper learning curve than Meshtastic. There’s less hand-holding, fewer out-of-the-box tools, and you’ll need to understand networking concepts beyond “press button, send message.” But that complexity buys you capabilities that ad-hoc platforms can’t match.

What is MeshCore?

MeshCore is a modular, highly customisable mesh networking platform designed for structured community applications. Born from the work of Liam Cottle in New Zealand and Andy Kirby in the UK, it was shaped by the hard lessons of Cyclone Gabrielle—where the need for a reliable, infrastructure-first backup network became a matter of survival rather than a hobby.

Unlike Meshtastic’s focus on accessibility, MeshCore prioritises scalability and network hygiene. The platform supports multiple physical layers—not just LoRa, but also FSK, GFSK, and other Sub-GHz modulation schemes. This flexibility means you can fine-tune for your specific case: long range, high throughput, low power, or a balance of all three.

MeshCore networks can scale to hundreds of nodes while maintaining reliable routing. The protocol includes features like quality-of-service (QoS) management and multi-path routing—capabilities that aren’t usually found in simpler flooding meshes.

Architecture and Design Philosophy

MeshCore’s architecture reflects its infrastructure-first design. Rather than providing a single, opinionated way of doing things, it offers a framework you can configure and extend.

Key architectural elements include:

Modular Protocol Stack

MeshCore separates concerns into distinct layers—physical radio, MAC layer, routing, transport, and application. You can swap components at each layer without affecting others. Need a different routing algorithm? Plug it in. Want to use a different radio module? Configure the physical layer.

This modularity is powerful but requires understanding how the pieces fit together. You’re not just toggling settings—you’re building a system.

Advanced Routing

The routing layer supports multiple approaches: flooding for small networks, tree-based routing for hierarchical setups, and gradient routing for larger meshes.

Unlike Meshtastic’s flood routing—where every node is a repeater that shouts everything it hears—MeshCore distinguishes between node roles. Companions (end-user devices) stay quiet to save battery, while Repeaters (dedicated infrastructure) handle the heavy lifting of routing. This separation improves efficiency and prevents the “broadcast storms” that can cripple ad-hoc networks.

QoS and Priority Management

MeshCore allows you to prioritise traffic. Critical alarm messages can be flagged for priority handling, ensuring they get through even when the network is busy with routine telemetry.

This is essential in agricultural or community-safety setups where some data is time-critical (alarms, gate sensors) while other data is merely informational (periodic soil moisture readings).

Hardware Requirements

MeshCore is less prescriptive about hardware than Meshtastic. It’s designed to run on various platforms, though most builds use:

• ESP32 or STM32 microcontrollers
• SX127x or SX126x LoRa transceivers
• External power or larger batteries for continuous operation
• Peripherals like GPS, temperature sensors, or relays

The flexibility means you can build custom hardware for your specific environment. Need ultra-low power for solar operation in the back paddock? You can build that.

However, this comes with a cost: there’s no “grab a $30 board from AliExpress and you’re done” shortcut. You’re either building custom boards or adapting development kits, both of which require more technical grit than a plug-and-play approach.

Configuration and Management

Where Meshtastic offers friendly mobile apps, MeshCore typically requires configuration files and command-line tools.

Configuration involves setting:

• Radio parameters (frequency, bandwidth, spreading factor)
• Network topology and routing preferences
• Power management policies
• Security policies and encryption keys

You’re not tapping buttons in an app—you’re editing JSON or XML files and potentially writing code to handle your specific data protocols. For a serious deployment, this isn’t a bug, it’s a feature. You need this level of control. But it means the barrier to entry is higher.

Real-World Performance

I put MeshCore through some serious testing in an agricultural setting recently, pitting it against Meshtastic to see how it handled a simulated network of soil moisture sensors and weather stations.

The differences were clear:

Scalability

Managing a test bed of over 10 nodes was significantly more stable than a similar Meshtastic setup. The routing protocol handled the structure well, and the distinction between companion and repeater roles meant the airwaves stayed much quieter.

Reliability

MeshCore’s multi-path routing meant the network stayed up even when I moved nodes or blocked line-of-sight. The system adapted without me having to fiddle with it.

Power Efficiency

By fine-tuning wake/sleep cycles, I saw how much further a battery could go when the device wasn’t forced to repeat every single packet from its neighbours. MeshCore’s power management is sophisticated, but it takes time to get it right.

Getting to this point required a real time investment. I spent days digging into configuration options and testing parameters. This isn’t a “weekend project” for the uninitiated.

Security Capabilities

MeshCore offers more robust security tools:

• Multiple encryption algorithms - AES-128, AES-256, and ChaCha20
• Key management - Support for key rotation and hierarchical structures
• Authentication - Cryptographic node authentication to keep the mesh clean
• Secure boot - Hardware security on supported platforms

These features are vital for community networks handling sensitive data, but they require some cryptographic understanding to set up properly.

Where MeshCore Excels

Based on my testing, MeshCore shines in:

Community Infrastructure

When you’re building a permanent “utility” mesh over a town or district. The scalability and management features handle complexity that would overwhelm an ad-hoc flooding mesh.

Agricultural Monitoring

Setups requiring reliable communication across larger properties. The QoS features ensure the irrigation controller gets the “off” command even if the weather station is busy uploading a big log.

Custom Builds

When your requirements don’t fit the standard mould. The modularity lets you build exactly what you need.

Where MeshCore Falls Short

MeshCore’s strengths come with trade-offs:

Complexity

The learning curve is steeper. You need networking knowledge and embedded systems experience.

Documentation

The documentation is technical and assumes you already know your way around a radio stack. There are fewer tutorials and a smaller community than the massive Meshtastic crowd.

Cost and Time

Hardware isn’t always off-the-shelf, and development time is substantial. For a small, three-node chat group, this overhead is hard to justify.

When to Choose MeshCore

Consider MeshCore when:

• Scale matters - You need to support dozens of nodes reliably
• Structure is essential - You want a clear distinction between backbone and end-users
• Reliability is critical - You’re building a network that people will depend on
• You have the technical grit - You’re comfortable with networking and code

Don’t choose MeshCore when:

• You’re just playing around - Stick with Meshtastic for a fun weekend project
• Small deployments - Three nodes in a park don’t need infrastructure-grade routing
• Quick results are needed - If you need it working by Saturday morning, look elsewhere

My Verdict

I’ve put MeshCore through its paces in the field, and while my testing was limited to a specific project window, the results were consistent. It is a far superior approach for structured communication over LoRa compared to the rudimentary flooding of Meshtastic, addressing many of the congestion issues that plague larger ad-hoc networks.

However, I wouldn’t reach for MeshCore for casual use. Its complexity isn’t justified for simple cases where a lighter tool might do, though I’ve yet to find Meshtastic reliable or secure enough for anything I’d call a “serious” network.

Think of MeshCore as professional-grade equipment. It requires more investment and a better understanding of the craft to use properly, but the results are on a different level.

Next week, I’ll look at Reticulum—the platform where I’ve ultimately settled for my serious communication needs. It builds on the strengths of structured networks like MeshCore but takes a radically different path, prioritising privacy, security, and transport independence in ways that neither Meshtastic nor MeshCore fully attempt.

• Lpwan
• Mesh Networks
• Meshcore
• Iot
• Agricultural