Meshy/MeshCore, Meshtastic, BitChat, DTN — could our envelopes ride LoRa, BLE and bundle networks? Carrier-plugin sketch · content/mesh-pipelines.md

Mesh & Unconventional Pipelines — could QALS ride them?

Date: 2026-09-14 (research window 2026-09-12→14) · Question (founder): "analysis of mesh networks like Meshy and whether a system like this could allow transfer across unconventional data pipelines like that." Companions: Qal Chat design (envelope + ferry model) · Data Sizing (measured bytes) · Encryption Explained.

The one-line answer: our envelope model was accidentally designed for this — opaque, self-verifying ciphertext blobs with pull-based delivery are the ideal payload for every transport in the mesh landscape, because the transport only ever has to move bytes it cannot read. The chain never needs to see the mesh: anchoring is deferred until any participant reconnects, and that spool already exists.

1. What "Meshy" actually is (2026)

Three different things share the name; the founder almost certainly means the first two:

1. Meshy the MeshCore client — meshy-app.org (accessed 2026-09-12): a free/GPL-3.0 desktop client (GTK4, Linux + macOS, v26.08) for MeshCore LoRa mesh devices — Heltec V3, T-Beam, WisBlock companion radios over Bluetooth/USB/TCP. Encrypted DMs, channel chat, contacts, map with hop counts, radio stats. On Flathub as page.codeberg.sesivany.Meshy. This is genuinely a mesh-networking product.
2. Meshy.ai — the famous AI 3D-generation tool (text/image→3D). Meshy-6 shipped 2026-01-18 (meshy.ai/blog), Meshy 7 live by Aug 2026 (Substack hands-on 2026-08-19). Nothing to do with networking — but the name collision is real and probably how the word reached us.
3. Meshy (MSmithDev/Meshy on GitHub) — a Discord bot bridging Meshtastic mesh traffic to Discord.

So: "mesh networks like Meshy" = the LoRa mesh world (MeshCore + Meshtastic) and its Bluetooth-messaging cousins. That's what the rest of this page analyses.

2. The mesh landscape, 2025-26 (status, mechanism, pipeline style)

The best single snapshot of the app-level space is Radar's comparison page (radar-chat.app/compare_mesh_chat.html, "2025 landscape"): "Most are dead… none interoperate." Dated status per project:

Two systemic facts matter more than any row: (1) zero interop — every local-radio protocol is an island (radar-chat); (2) phone radios are hostile — BLE ads cap at 31 bytes, default GATT MTU is 23 bytes (3 usable until negotiation), ~7-10 concurrent GATT connections, scan throttling, Doze kills background mesh; iOS forbids background BLE advertising outright (radar-chat, 2025). That's why LoRa hardware keeps winning real deployments.

3. Could QALS ride these pipelines? Mapping the envelope model

Our shipping model (qalchat/DESIGN.md, 2026-09): an envelope is a JSON blob {from, to, ciphertext, nonce, ts, msg_hash, sig, ctr, pub} — self-verifying (ed25519 signature, per-conversation hash chain, counter), opaque to any carrier, delivered by pull (recipient polls, then DELETEs with an ack). The offline ferry (export-env/import-env, shipped and tested 2026-09-09) already moves custody of ciphertext through a plain file. Payments ride inside the ciphertext (~712 B measured, data-sizing.md §1); anchoring is a separate, deferred step (qalpipe → DataAnchor).

The consequence: a "mesh" for us is anything that can hold and forward opaque bytes. The transport never needs crypto of its own — Bridgefy's broken crypto or MeshCore's weak payload MAC are irrelevant to us, because the inner envelope is what protects the content; carrier crypto is belt-and-braces. What each class changes and what survives:

3.1 Bluetooth device mesh (BitChat/Briar style) — research

Envelopes gossip phone-to-phone exactly like BitChat's messages. What changes: latency becomes minutes-to-hours (delivery only when chains of devices touch); MTUs are brutal (a 712 B envelope = 3-4 GATT writes even after MTU negotiation); no relay means no visibility, so anchoring waits for any participant's reconnection — by design, nothing in our chain cares when the anchor happens. What stays: crypto, dedupe (nonce equality — already implemented), chain reconciliation ("everything after hash X", DESIGN §4). New risks: eclipse/jamming (someone surrounds a node and feeds it a fake view — the chain detects tampering at reconciliation, not drops), battery (radar-chat: full mesh mode drains a phone in hours). Label: research — Android BLE is the hardest build in the space; BitChat is the existence proof that it's possible.

3.2 LoRa specifically (Meshtastic/MeshCore) — build

The math (from data-sizing.md, all measured constants): envelope ≈ 380 B fixed overhead + 1.33 × payload; the typical ⚡ payment = 712 B. Meshtastic's practical radio payload is ~200-230 B per frame depending on spreading factor [UNVERIFIED exact bytes per SF — check firmware docs for the region preset]. So: one payment envelope ≈ 3-4 LoRa frames; airtime a few seconds each; a handful of messages = minutes of duty cycle. The graceful degradation ladder:

• Anchor-as-hash: one conversation Merkle root = 32 B — fits in a single LoRa frame with room to spare. The on-chain proof of a whole conversation crosses a mesh for the price of one ping.
• Payment stubs: a stripped "I paid you, receipt id r_…" notice is designable well under 200 B (receipt median is 209 B at rest, data-sizing §4) [design estimate, not built].
• Full envelopes: chunked with a tiny manifest (our file-chunking already does exactly this pattern at 256 KiB scale; LoRa reuses the idea at 10⁻³ the chunk size).

Trust note: on Meshtastic public channels everyone sees metadata (handle, timestamp) and the default channel key is shared — fine, because the envelope is sealed inside; use a private channel key as a courtesy, not as the security boundary. Label: build — a Python daemon speaking the Meshtastic serial/BLE API (the same APIs the Meshy client uses) implements put(envelope)/poll(handle) in days.

3.3 DTN / Bundle Protocol — build (the ferry, formalised)

BPv7 (RFC 9171) is literally our ferry with a standards body behind it. Mapping: envelope → bundle ADU; relay → DTN node (dtn7-go's dtnd); recipient handle → EID (dtn://handle.qals); poll → bundle delivery + status reports; our 24 h TTL → bundle lifetime; ack → BP status report. Nothing conceptual is new — this is a rename table — but adopting it buys convergence layers (TCP, BLE, LoCaH) and interop with the space/defense DTN ecosystem for free. Label: build; worth doing as the reference carrier precisely because it's standardised.

3.4 Storage meshes (IPFS/Swarm) — works today, niche fit

Envelope JSON → content-addressed blob; relay = any pinning node; the "poll" is resolving the hash list, exchanged over any side channel (even LoRa — 32-byte hashes again). IPFS is alive and this works today; Swarm's incentive layer is effectively dead (§2), so treat it as precedent, not infrastructure. Label: works today (IPFS), but it still needs some internet endpoint — it's a relay substitution, not a true offline path.

3.5 Yggdrasil / cjdns overlays — works today, zero changes

Yggdrasil hands you an encrypted IPv6 address reachable over any underlying transport (it runs over IPv4 too). Point QALCHAT_RELAY at a relay's Yggdrasil address and the entire stack — envelopes, files, anchoring — works unchanged, transported through an actual experimental mesh. This is the cheapest possible demonstration of "unconventional pipeline": config, not code. Label: works today.

3.6 The extremes: sneakernet, satellite, drone — ferry already shipped

export-env/import-env over USB is a pigeon-compatible transport. Everything upstream is a generalisation: SD cards in the mail (rural AU), store-and-forward LEO satellite [UNVERIFIED — vendor landscape shifting, verify before relying], goTenna-style UHF kits now that Forterra owns them, festival drones as mules. The pattern is identical every time: physical custody of ciphertext, anchor on reunion.

4. Design sketch: the carrier plugin

Formalise what the client already does. Today grecv polls HTTP relays; a carrier is just a new implementation of two verbs:

put(envelope)          # hand ciphertext to the pipeline
poll(handle) → [envelopes]   # pull whatever arrived for me

• http — current relay (:8830/:8840). carrier #0.
• ferryfile — export/import. carrier #1 (shipped as commands; wrap as a carrier).
• lora — serial daemon → Meshtastic/MeshCore radio; chunked envelopes + 32-byte anchor fast-path.
• dtn — local dtnd; envelope↔bundle, handle↔EID.
• ipfs — pin + announce hash list.
• ble — phone-mesh gossip (research tier).

What the chain needs: nothing. Anchoring is already deferred (qalpipe spools to anchors.jsonl; a conversation anchors whenever anyone reconnects — the Merkle root doesn't care when). loopd receipts are local paper entries; the ⚡ message announces, the settlement reference rides inside the ciphertext. What mesh carriers see: exactly what relays see — ciphertext + handles + timestamps (metadata-lite). What mesh adds: jamming, eclipse, replay-after-TTL, and silent drops (the chain detects tampering, not drops — DESIGN §4.2 — so acknowledge-drop is a carrier-level QoS question, not a crypto one). One honest gap: offline double-spend of paper receipts — if both parties transact offline against the same loopd balances and reconcile late, the paper ledger can conflict; escrow/holds (qal_credit) or single-device-of-authority rules are the containment paths [design question, open].

5. Use-case verdicts

1. Disaster/censorship comms — the killer use case. Precedent is no longer hypothetical: New Delhi protesters ran BitChat through shutdowns (restofworld 2026-08-06); India's takedown orders (2026-07) prove demand and that app-store removal is the failure mode — which a carrier-plugin CLI on any HTTP endpoint largely sidesteps. QALS adds what BitChat doesn't have: signed, chain-anchored conversations and in-message value.
2. Remote stations (farms/mines, AU). Solar LoRa node + occasional NBN reconnect = a station relay with weeks of autonomy. Sensor readings and worker comms flow over LoRa (anchor hashes cross instantly); payrolls settle on reconnect. Honest label: build, and the station-hardware BOM (~A$50/radio) is the cheap part.
3. Festival / local-only commerce. Crowd-density BLE + a local relay box; buyers and vendors trade ⚡ with no internet; escrow settles when the box hits the internet (qalbazaar-adjacent). Bridgefy proved the crowd scale; our cryptography survives the audit Bridgefy failed.
4. IoT sensor backhaul with receipts. LoRaWAN-shaped: sensor → mesh → gateway, each reading hash-anchored (426 B/line, data-sizing §3), machine-to-machine payments to sensor owners. The most commercially plausible pipeline after disaster comms, and the most natural fit for agent-to-agent traffic.

Bottom line. "Meshy" points at a LoRa-mesh world that boomed while we were building — and our architecture turns out to be shape-compatible with all of it: opaque self-verifying envelopes, pull delivery, deferred anchoring, shipped ferry. Working today: HTTP relays, Yggdrasil, ferry. Weeks of build: LoRa + DTN carriers. Research tier: phone BLE mesh, eclipse-resistance, offline double-spend containment. The chain itself needs zero changes.

Sources (accessed 2026-09-12/14): meshy-app.org · flathub.org (sesivany.Meshy) · meshy.ai/blog · d-central.tech 2026-07-18 · simeononsecurity.com 2026-06-26 · smartnmagic.com 2026-08-01 · nepamesh.com 2026-07-01 · radar-chat.app (2025 landscape) · bisi.org.uk 2026-01-27 · restofworld.org 2026-08-06 · medianama.com 2026-07-27 · getsession.org (migration 2025-05-21) · iacr.org 2026-04-22 (EuroS&P Session attacks) · CoinMarketCap BZZ · yggdrasil-network.github.io · datatracker.ietf.org RFC 9171 / RFC 4838 · dtn7.github.io · gotenna.com 2025-05-06 · soldiersystems.net 2025-10-09 (Forterra acquires goTenna) · internal: qalchat/DESIGN.md (2026-09-08) · content/data-sizing.md (2026-09-12). Items tagged [UNVERIFIED] are single-source or memory-based — verify before external claims.