MeshBench

MeshBench runs real MeshCore firmware. MeshBench models the air.

MeshCore is the open-source LoRa mesh firmware; MeshBench is the instrument it is measured with: an RF-accurate network simulator. It runs real MeshCore firmware against a modelled radio channel, so the question it answers is not "would a packet get through" but "what actually arrived at the antenna, and why".

Reception is decided one of two ways. Calculated is the default: a link budget against the demodulator's floor, fast enough for a national network. Waveform synthesises the actual chirps and runs a real demodulator over them, so capture and collision emerge from the physics rather than from a rule. Both price the same path; see RF simulation. The firmware is never simulated: every node is the real MeshCore application running against a modelled radio. What is real, and what is modelled is the two-minute version of that mental model.

One binary on your machine. No service to deploy, no account, nothing to configure before the first run.

The workbench: the shipped Scotland and Ireland network on the map, links drawn, real firmware running on every node

You Planning a network where does the next node go Writing firmware did my branch relay more Writing an app how does it cope with a bad link One binary the workbench the command line three clients, in your tests no service, no account, nothing to configure first Real firmware, honest physics MeshCore’s own firmware routing, flood suppression, CSMA timing a sample-accurate LoRa channel modelled from physics, not from rules real elevation data and, if you load them, buildings The channel decides nothing. It sums waveforms, applies path loss and adds noise. Whether a packet decodes is the demodulator’s business, so capture effect and partial collisions emerge from the physics instead of from a rule somebody wrote down.
Three questions, one binary. The firmware is the thing itself; the air it transmits into is modelled, from physics rather than rules.

What it is for#

feed, and ask.

Start here#

if you want toread
understand what is real and what is modelledWhat is real
install and launch itGetting started
run a real network in fifteen minutesYour first simulation
know how much to trust a numberReading a result
use a ready-made networkShipped networks
bring in a real networkImporting a network
find out why a packet failedDebugging packet delivery
test a firmware changeFirmware development
write a client against itApp development
test your own firmware or appTesting your own code
compare two configurationsExperiments
drive it from a scriptControl socket
know how it works insideArchitecture
understand how reception is decidedRF simulation
know what the build refusesWhat the build enforces

What it does not do#

The simulator is kinder than the air. There is no multipath, no body loss, no oscillator drift. The measured biases nearly all run one way, which is what makes a result usable: treat every absolute number as a best case, and trust the *comparison* between two runs far more than either run alone.

It is a desktop application, not a web service. "On the GPU" always means the GPU in the machine running it, and every GPU path has a CPU path that produces the same answer more slowly.

MeshBench documentation. Built from the running application, not from mock-ups. Screenshots are window-only captures; see CLAUDE.md for the rule that keeps them current. Edit this page.