Over the last few years, LoRa (Long Range radio) has become one of the most popular technologies for building long-distance, low-power wireless communication systems.

Unlike Wi-Fi or Bluetooth, LoRa is designed for kilometer-scale communication using very little power. This makes it ideal for applications like:

• remote sensors
• off-grid communication systems
• IoT networks
• community mesh networks

One project that has recently gained attention in the LoRa community is MeshCore.

MeshCore is software designed to run on embedded LoRa devices that allows them to form decentralized mesh networks capable of forwarding messages across multiple nodes.

Instead of requiring cellular towers or internet infrastructure, MeshCore networks can operate entirely peer-to-peer.

This makes them useful for situations where traditional communication infrastructure is unavailable or unreliable, such as:

• disaster response
• remote communities
• outdoor expeditions
• experimental DIY networking projects

In this guide, we’ll break down exactly how MeshCore works, including the node roles, hardware options, radio configuration, and how real MeshCore networks are deployed.

What Is MeshCore?

MeshCore is a LoRa-based mesh networking platform designed for embedded devices.

The project allows devices equipped with LoRa radios to communicate by forwarding messages through other nodes in the network.

Instead of relying on a central gateway or server, MeshCore networks operate using multi-hop packet routing, meaning messages can travel across multiple intermediate devices until they reach their destination.

For example:

Each node helps extend the network’s overall coverage.

Because LoRa radios can communicate over several kilometers depending on terrain and antenna configuration, a MeshCore network can potentially cover very large geographic areas with relatively few devices.

The project focuses on enabling:

• decentralized communication
• low-power networking
• long-range message forwarding
• experimental mesh deployments

MeshCore is still evolving, and some parts of the ecosystem are actively being developed.

How MeshCore Works

To understand MeshCore, it’s helpful to first understand the basics of LoRa radio communication.

LoRa Radio Basics

LoRa is a modulation technique designed specifically for:

• long range
• low power consumption
• small data packets

LoRa devices operate in unlicensed ISM frequency bands, including:

• 868 MHz (Europe)
• 915 MHz (North America and Australia)
• 433 MHz (used in some regions)

Because these bands are license-free, anyone can deploy LoRa devices as long as they follow regional transmit power and duty cycle regulations.

LoRa is excellent for sending small packets of data over long distances, but it is not designed for high-bandwidth communication.

Multi-Hop Packet Forwarding

The key feature of MeshCore is multi-hop packet routing.

Instead of sending messages directly between two devices, packets can travel through intermediate nodes.

Example:

In this scenario:

• Node A cannot reach Node D directly
• Node B and Node C forward the packet

This allows networks to grow organically as additional nodes are deployed.

Decentralized Networking

MeshCore networks are designed to operate without centralized infrastructure.

This means they do not require:

• internet connectivity
• cellular networks
• centralized servers

Each node communicates directly with nearby nodes.

Because messages can take multiple paths through the network, this design increases resilience if individual nodes go offline.

MeshCore Node Roles

One of the distinguishing features of MeshCore is the use of different node roles.

Instead of every device behaving the same way, nodes are assigned specific roles that determine how they interact with the network.

The primary node types are:

• Companion Nodes
• Repeaters
• Room Servers

Companion Nodes

A MeshCore companion node is typically the device used directly by a user.

These nodes connect to devices such as:

• smartphones
• laptops
• handheld radios

Their role is to provide a user interface into the mesh network.

Companion nodes allow users to:

• send messages
• receive messages
• interact with mesh communication channels

Unlike infrastructure nodes, companion nodes generally do not forward packets for other users.

This design helps prevent unstable routing paths caused by mobile devices moving around the network.

Instead, packet forwarding is handled by dedicated infrastructure nodes.

Repeaters

Repeaters act as the core infrastructure nodes of a MeshCore network.

Their purpose is simple:

receive packets and retransmit them to extend network coverage.

Repeaters are typically installed in fixed locations such as:

• rooftops
• towers
• hills
• tall buildings

Because repeaters are stationary and strategically positioned, they provide more reliable routing paths than mobile nodes.

Large MeshCore networks rely heavily on well-placed repeaters to maintain connectivity across wider areas.

Room Servers

Room servers provide an additional feature in MeshCore networks: message persistence.

Unlike repeaters, which simply forward packets, room servers can store messages and allow them to be retrieved later.

This allows for asynchronous communication, meaning users do not need to be connected to the network at the same time.

Example:

1. User A sends a message to a room.
2. The room server stores the message.
3. User B connects later and retrieves it.

This behavior is somewhat similar to a basic bulletin board system (BBS).

MeshCore documentation says a room server can be set to repeat, but this is not the recommended approach. The docs recommend using separate devices for repeater and room server roles, since a room server with repeating enabled lacks the full feature set of dedicated repeater firmware.

Hardware That Runs MeshCore

MeshCore is designed to run on microcontroller-based LoRa hardware.

These devices typically include:

• a microcontroller (such as an ESP32)
• a LoRa radio transceiver
• optional peripherals like displays or sensors

Common hardware used for MeshCore nodes includes:

• Heltec LoRa boards
• LilyGo LoRa devices
• RAK Wireless LoRa boards
• ESP32-based LoRa development boards

Many of these boards combine an ESP32 microcontroller with a Semtech LoRa radio chip such as the SX1276 or SX1262.

Devices become part of a MeshCore network once the appropriate firmware is flashed.

Radio Configuration

All nodes in a MeshCore network must share the same LoRa radio parameters.

If radio settings differ, devices will not be able to decode each other’s transmissions.

Important LoRa parameters include:

Frequency

Defines the radio channel used by the network.

Common frequencies include:

• 868 MHz (Europe)
• 915 MHz (North America and Australia)

Bandwidth

Bandwidth determines the width of the radio channel.

Common LoRa bandwidth values include:

• 62.5 kHz
• 125 kHz
• 250 kHz

Lower bandwidth improves receiver sensitivity but reduces throughput.

Spreading Factor

Spreading factor controls symbol duration and affects both range and data rate.

Typical values:

• SF7 – faster but shorter range
• SF12 – slower but longer range

Coding Rate

Coding rate adds forward error correction to improve reliability in noisy environments.

All nodes must share identical values for:

• frequency
• bandwidth
• spreading factor
• coding rate

Otherwise communication will fail.

Network Range and Performance

The range of a MeshCore network depends heavily on environmental conditions.

Typical LoRa ranges are roughly:

However these values vary significantly depending on:

• antenna gain
• antenna height
• terrain
• buildings and obstacles
• radio configuration

Because MeshCore supports multi-hop routing, the total network coverage can extend far beyond the range of a single radio link.

MeshCore vs Meshtastic

MeshCore is often compared with Meshtastic, another LoRa mesh messaging platform.

Both systems allow devices to communicate over LoRa mesh networks, but they use different architectural approaches.

Meshtastic

• Many nodes rebroadcast packets
• Mobile nodes can forward traffic
• More ad-hoc routing

MeshCore

• Uses structured node roles
• Packet forwarding is primarily handled by repeaters
• Companion nodes typically do not forward traffic

This design tends to reduce unnecessary retransmissions and routing instability.

Typical MeshCore Network Deployment

A simple MeshCore network might look like this:

User Companion Node
        │
     Repeater
        │
     Repeater
        │
    Room Server
        │
   Other Companions

In real deployments, networks often include:

• rooftop repeaters
• portable companion devices
• room servers storing messages

As additional nodes are added, the mesh network expands and coverage improves.

Advantages of MeshCore

MeshCore offers several advantages for experimental and off-grid communication networks.

Decentralized communication

Networks can operate without internet infrastructure.

Long range

LoRa radios can communicate across kilometers.

Resilient architecture

Multi-hop routing allows multiple possible paths for packets.

Low power operation

LoRa radios are designed for battery-powered devices.

Limitations and Challenges

MeshCore also has several limitations.

Low bandwidth

LoRa networks are designed for small packets of data.

They are not suitable for:

• voice communication
• large file transfers
• video streaming

Infrastructure requirements

Repeaters must be strategically placed for networks to function effectively.

Evolving ecosystem

MeshCore is still developing and parts of the ecosystem continue to evolve.

Hardware compatibility

Documentation does not clearly specify compatibility for every LoRa development board.

Getting Started with MeshCore

Building a MeshCore network typically involves the following steps.

1. Obtain compatible hardware

Examples include:

• Heltec LoRa boards
• LilyGo LoRa devices
• RAK Wireless LoRa boards

2. Flash MeshCore firmware

Firmware can usually be flashed using:

• official MeshCore Web Flasher
• USB-based setup through the MeshCore web configuration tool
• OTA update tools supported by the device platform

3. Configure radio parameters

Ensure all nodes share identical settings.

4. Assign node roles

Devices can be configured as:

• companion nodes
• repeaters
• room servers

5. Deploy nodes

Once several nodes are active, the mesh network begins to form automatically.

Conclusion

MeshCore is an emerging project that explores decentralized communication using LoRa mesh networking.

By separating devices into structured roles such as companions, repeaters, and room servers, MeshCore attempts to create a more organized mesh network architecture than some other LoRa projects.

Although the project is still evolving and documentation for some internal behaviors is limited, MeshCore demonstrates how inexpensive embedded devices can be used to build resilient long-range communication networks.

For makers and radio enthusiasts, MeshCore provides an interesting platform for experimenting with:

• off-grid communication
• LoRa networking
• community mesh deployments
• embedded radio systems