Meshtastic-Apple turns an iPhone into a terminal for a LoRa mesh

A client for hardware that already exists in the field

Meshtastic is a mesh network built on LoRa radio hardware, and the radio is the thing that does the work. Meshtastic-Apple is the client for that hardware on Apple platforms, described as SwiftUI applications for iOS, iPadOS, macOS, visionOS and watchOS that communicate with LoRa mesh radio devices over Bluetooth, TCP and serial.

That positioning explains the scope. If all you wanted was to read messages, a chat screen would do. Instead the app covers mesh messaging on channels and direct messages, a live map with node positions, waypoints and GeoJSON overlays with offline tiles, node management with a signal meter, device roles, encryption status, trace routes and telemetry, and full radio configuration covering LoRa, channels, security, Bluetooth, device, display, network, position, power and all module configs.

The user is someone who owns one or more radios and wants to tune them without a laptop and serial cable, and who is on the move enough to want CarPlay and Siri support for hands-free messaging while driving. The Apple Watch companion, offering a node list and a fox hunt compass on the wrist, extends that same idea to a smaller screen.

The one thing to be clear about is that this app does not create a mesh. It is a control surface and a terminal for a mesh that already exists.

Three transports, one radio abstraction

The mechanism worth understanding is the transport split. The same client talks to a radio over Bluetooth, over TCP and over serial, which matters because Meshtastic radios are deployed in three different contexts.

Bluetooth covers the tethered case, a handheld radio or a node worn or carried by someone nearby. TCP covers a radio that sits on a network and is reachable remotely. Serial covers the bench case, where a radio is plugged into a Mac with a cable during setup or firmware work. The repository layout backs this up, with MeshtasticMessages and MeshtasticProtobufs directories alongside a protobufs directory and a Packages directory, which is where a shared message and protocol layer would live.

Because the same operations reach the device through different links, the app's job is to present one radio to the user while the transport underneath changes. That is also why configuration matters so much in this app. LoRa settings, channel definitions, encryption state and the module configs are all device state that the app edits and reads back, and the app exposes the lot rather than a curated subset.

The watch app syncs with the iPhone rather than talking to the radio directly, so the watch view is a projection of what the phone already knows. The documentation describes the companion app as a node list, a fox hunt compass, and something that syncs with the iPhone, which is a sensible split given watch battery and radio constraints.

The app is the configuration surface, not just a chat client

Most of the differentiating surface is in the configuration screens and the surrounding integrations.

Beyond the radio settings, the app supports TAK integration with CoT position relay and TAK server connectivity, which is what turns the mesh into a position source for tactical awareness tooling. The live map handles node positions, waypoints and GeoJSON overlays, and it works with offline tiles, so the map is usable where there is no cell coverage and no network.

Node management is unusually deep for a consumer app: a signal meter, device roles, encryption status, trace routes and telemetry all live there. A trace route is the feature that explains the network to a newcomer, since it shows the path a packet took across repeaters, and the signal meter page added in May 2026 goes further, explaining how the LoRa signal quality meter works, why negative SNR values are normal, and how to read RSSI against SNR.

Local Mesh Discovery, added in April 2026, is a diagnostic rather than a user feature. It cycles through multiple LoRa modem presets to audit the local RF environment, collecting nodes and telemetry across presets with configurable dwell times. That is the kind of tool that tells you whether a node is unreachable because it is absent or because the preset is wrong.

One feature is worth calling out as a boundary rather than a capability. The in-app documentation includes AI-powered search, which the README scopes to iOS 26 and later and attributes to Foundation Models. On earlier systems that search simply is not there, so a team supporting a mix of devices should not design around it.

Cloning the repo and building the workspace

The getting started path is short, and it deliberately avoids extra tooling.

Clone the repository:

git clone [email protected]:meshtastic/Meshtastic-Apple.git

Move into the directory:

cd Meshtastic-Apple

Set up the git hooks that lint the project on commit:

./scripts/setup-hooks.sh

Then open the workspace:

open Meshtastic.xcworkspace

and build and run the Meshtastic target from Xcode. A lint configuration is committed at the repository root in .swiftlint.yml and .swiftlint-precommit.yml, which is what the hook uses.

The XcodeGen detail is worth understanding, because it looks like a tooling requirement and is not one. Meshtastic.xcodeproj is generated from project.yml by XcodeGen, but the project file is committed to the repository, so the steps above need no extra tooling. You only need XcodeGen if you change targets, build settings or dependencies, in which case you edit project.yml, regenerate with the version pinned in .xcodegen-version, and commit the result. Adding, moving or deleting source files needs neither.

That arrangement has a clear benefit for contributors: a fork or an internal mirror builds without installing a project generator, and the generated project file stays reviewable in diffs.

One documentation set, shipped three ways

The documentation system is unusual enough to be worth its own look, and it is described in the developer notes as well as the user guide.

The source of truth is markdown under docs/. From there the project produces a GitHub Pages Jekyll site, the User Guide and the Developer Guide, and an in-app browser that works offline with dark mode support. The conversion step is a script, scripts/build-docs.sh, which turns the markdown into HTML bundled at Meshtastic/Resources/docs/, and navigation is driven by an index.json file. Inside the app, the documentation is reached from Settings, then Help and Documentation.

The AI-powered search in that browser, on iOS 26 and later, is built on Foundation Models. The system prompt file for it is not something you will find in the repository listing, so the configuration lives in the app target rather than in a visible file.

There is also a translation pipeline described for May 2026, where each device contributes on-device translations that are shared through a CDN feed so later users get localised documentation without waiting for a release, and on iOS 26 and later the in-app documentation is translated into the device language using the Apple Translation framework.

For a user, the effect is that help does not require a network connection, which is the only situation many of these radios live in.

Release cadence, licence and what a fork costs you

The repository is not archived and the last push was on 2026-10-19. The release line moved fast in the same month: v2.7.22 and v2.7.23 on 2026-10-02 and v2.7.24 on 2026-10-07. Two releases on the same day, with the 2.7.23 and 2.7.22 tags minutes apart, suggests a pipeline that can cut several builds in one session.

The release procedure itself is documented separately in RELEASING.md, which the README points to rather than duplicating. The development guide also documents a testing convention that was established in May 2026: snapshot tests consolidate multi-state views into single combined images as light and dark pairs, using an assertViewSnapshot helper with explicit width and height and transparent set to true for icon snapshots.

On the licence, the project is GPL v3, and the README says so plainly with a pointer to the LICENSE file. That is the part of the decision to take seriously. A GPL v3 client is a reasonable choice for a client that is distributed alongside free firmware and free documentation, and the ecosystem here is built that way. It is also a licence with obligations that attach to derivative works, so if you plan to embed parts of this client in a closed application or ship it inside a product with a different licence, read the terms for your specific arrangement rather than assuming the client code is a free dependency.

For a fork, the practical upgrade cost is the usual one for an active SwiftUI project: the app follows its own tooling, here XcodeGen with a pinned version, Swift 6 as the language target, SwiftLint for style, and a committed generated project file.

Editorial conclusion

Adopt Meshtastic-Apple if you own Meshtastic radio hardware and want full configuration plus chat and mapping from an Apple device, and skip it if you need the radio to work with no phone in the loop, since this is a client for a mesh that is configured and used through the app. Verify first that the release you install matches your radio firmware expectations, since the 2.7.22, 2.7.23 and 2.7.24 releases all landed in October 2026, and read the GPL v3 terms against the licence of any app you intend to ship alongside it.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. meshtastic/Meshtastic-Apple on GitHub
3. Project website
4. README
5. Releases