# Columba is an Android messaging app that does not need the internet or a server

> Columba sends LXMF messages and makes LXST voice calls over the Reticulum network from an Android phone, using Bluetooth LE, WiFi, LoRa through an RNode or plain TCP, with identities generated on the device and no accounts anywhere. It is the clearest example of a mesh networking stack that is usable as an ordinary messaging app rather than as a demo.

**torlando-tech/columba** — Native Android messaging app using Bluetooth LE, TCP, or RNode (LoRa) over LXMF and Reticulum

- Repository: https://github.com/torlando-tech/columba
- Website: https://columba.network/
- Stars: 1,240 · Forks: 122
- Language: Kotlin
- License: MPL-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/torlando-tech-columba

## A messaging app on top of a mesh network

Columba is a simple messaging and voice app for the Reticulum network on Android, and it sends LXMF messages and makes LXST voice calls without relying on the internet, cell towers, or any central servers.

The distinction is worth stating precisely, because the pitch sounds like an offline mode and it is not. It is a different network. Reticulum is a networking stack that lets devices communicate directly with each other, forming resilient mesh networks, and it is optimized for low bandwidth, high latency connections and can communicate over nearly any medium.

So the messages travel from phone to phone, or from phone to a node with a radio, and the whole thing keeps working when the cell tower is gone because the tower was never part of the path.

The application itself is a native Android interface with Material Design 3, and the readme makes the point that this brings mesh networking to your pocket in a familiar package.

The implementation is Kotlin, the licence is MPL-2.0, the site is columba.network, and the last push was on 2026-10-15. The release history is v2.3.1-beta from 2026-10-07, v2.2.6 from 2026-09-25 and v2.2.5-beta from 2026-09-08, so the project is shipping betas alongside stable releases, which is a reasonable pattern for an app that talks to a moving network stack.

## Four ways to reach the other end

The list of what you can do is organised around the transport, and that is the part that decides whether the app is useful to you.

Message without infrastructure means you can send messages even when the internet is down or unavailable. Connect multiple ways is the longer entry: use Bluetooth LE to connect to those around you anywhere, WiFi for those at home, LoRa radio via an RNode for those at a distance, or TCP to connect to any Reticulum server around the world.

Those four are not interchangeable. Bluetooth LE is for a room. WiFi is for a building. LoRa through an RNode is for kilometres, and it needs a node with a radio and an antenna. TCP is for the case where you can reach a Reticulum node on the internet.

The BLE path is the one with the most work behind it, and the readme is explicit about it. Columba uses a native Android implementation of ble-reticulum to enable messaging over BLE with other Android and Linux devices, so the project maintains its own bridge between the Bluetooth stack and the Reticulum stack rather than relying on an existing one.

The result is that the app works with whatever hardware you happen to have, which is the point of a mesh network, and it is also the reason the app is more than an install-and-go product.

## Identities live on the device, and that is the design

The privacy entry is a list of features rather than a slogan.

Stay private means end-to-end encryption with no accounts, no tracking and no central servers. Keep your identity means you generate your messaging identity right on your device. Manage multiple identities lets you swap between them easily. Export and import identities keeps an external backup of your keys, or migrates to a new device, and the import works from other Reticulum clients like Sideband. And share your identity via QR code comes with a built in scanner and generator.

That set of features is the operational heart of a mesh messenger. The key is generated locally, it is your only credential, and there is no server to reset it and no account to recover it. The export and import path is therefore not a convenience, it is the only backup that exists, and a user who loses the device and the export has lost the identity permanently.

The multiple identity feature is what makes a mesh messenger practical for a normal life, because a single identity per person is too coarse when you are talking to different groups over different transports, and because the same person may be reachable over BLE in one place and over a TCP node in another.

The QR code sharing is the other detail that matters. Passing an identity over a side channel is how a mesh network bootstraps, and a scanner in the app is the difference between that being a manual copy and paste and it being a tap.

## Maps, NomadNet pages, and being part of the network

Three features are about the app being useful in the field rather than about the messaging itself.

Share location lets you share your location securely with others, viewable from a dedicated map, and download maps for offline use, where you can download or import map files in the MBTiles format, supporting both vector and raster.

Browse NomadNetwork lets you access NomadNet pages over Reticulum networks, which is a browsable set of pages published by people in the network rather than a chat log.

And build your network is the one with the most community consequence, because you help relay traffic for others and expand the mesh. That is a feature for the network and a cost for the battery for the person doing it, and any mesh system has that trade somewhere.

The offline map support is the detail that shows the app is aimed at people who are actually out there, since a messaging app that needs a signal to show you where you are is not much use in the situation the app is for.

The last feature on the list is cosmetic: custom color themes, with a rather good line about not liking the default colours.

## Getting the APK, and verifying it

The Getting Started section is short, and it offers three routes with an emphasis on verification.

The first is the releases page. You download the latest release and install it on your Android device, and the readme points at SECURITY.md for the APK verification instructions.

The second is Obtainium, and the readme embeds a badge that adds the project to it.

The third is the one that is worth a second look, because it is the same network the app uses. You can download the apk via NomadNet, at a specific Reticulum address.

That is a nice piece of design. The people who cannot reach the internet are exactly the people the app is for, so the installer is distributed over the network the app speaks, which means a deployment does not depend on the app store being reachable from the place you are deploying it.

It is also the reason the verification instructions matter. An APK fetched over a mesh network should be checked before it is installed, and the readme is not pretending otherwise by pointing at SECURITY.md first.

## The repository shows a large, layered Android project

The top level listing is long, and the rns- prefixed directories are the interesting part because they are the Reticulum network stack broken into layers.

There is rns-api/, rns-backend-kt/ for the Kotlin backend, rns-backend-py/ for a Python backend, rns-host/, rns-ipc/ and rns-stats/, alongside a domain/ directory for the application logic and a micron/ directory. The presence of two backends is the clearest sign of the multi transport design, since the same protocol has to be spoken over Bluetooth LE, over TCP and over a serial link to an RNode.

The app/ directory holds the Android application, and the build is a Gradle Kotlin DSL project with settings.gradle.kts, gradle.properties, the gradlew launchers and a detekt-config.yml with a detekt-rules/ directory, so the static analysis configuration is part of the project rather than a global default.

Then there is the tooling. There is a maestro/ directory and a screenshot-tests/ directory. There is an obtainium.json at the root, which is the configuration for the Obtainium install route, and a.codecov.yml for coverage. The scripts directory holds audit-dispatchers.sh and audit-dispatchers-full.sh, and there are build-and-launch.sh and deploy.sh at the top level for the developer loop.

A few files are documentation of a decision rather than of the code. port-deviations.md is named for ports, and september-2026-update.md is a dated note about a change, and both are the kind of artefact that explains why something looks odd in the source.

## Why the name is a dove

The last section of the readme is the name, and it is the kind of detail that says something about the project.

Columba, latin for dove, is a constellation in the southern sky depicting a dove. Doves are commonly a symbol of peace and hope, and have been used as messengers throughout history.

That is a good name for the project, and it is also a useful lens for what it is trying to be. A mesh messenger has no operator to appeal to and no account to recover, so the network survives because people run it for each other, and the message has to be one that people are willing to carry.

The readme points at Reticulum's own documentation for anyone who wants to learn more about the stack underneath, and the About Reticulum section is the shortest part of the readme because the project expects the network to be explained elsewhere and the app to speak for itself.

## Conclusion

Adopt Columba when you need messaging that works where there is no cellular coverage and no internet, and you are willing to learn how a mesh network is put together. Do not adopt it as a general messaging replacement, because every message goes over Reticulum rather than over a carrier, so the other party has to be on the same network or reachable through a node that is. Verify first which transport your nodes can actually reach, that the identity you generate is backed up before you need it, and that you understand the APK verification steps in SECURITY.md before installing a build from a third party mirror.

## FAQ

### What is the Columba app?

It is a native Android messaging and voice app for the Reticulum network, sending LXMF messages and making LXST voice calls without relying on the internet, cell towers or any central servers, with a Material Design 3 interface.

### Which transports can Columba use?

Bluetooth LE for devices nearby, WiFi for those at home, LoRa radio via an RNode for longer distances, and TCP to reach any Reticulum server. The BLE path uses a native Android implementation of ble-reticulum to talk to other Android and Linux devices.

### How does Columba handle identities and privacy?

There are no accounts, no tracking and no central servers, and the messaging identity is generated on the device. You can manage multiple identities, export and import them to keep a backup or migrate, and share one by QR code.

### Can Columba work offline?

Yes. You can send messages when the internet is down, and you can download or import map files in MBTiles format, both vector and raster, for offline use, and share your location on a dedicated map.

### How do I install Columba?

Download the latest release from the releases page, or use Obtainium to track the repository, or fetch the apk over NomadNet at the Reticulum address given in the readme. The readme points at SECURITY.md for the APK verification instructions.

### How is the Columba repository structured?

The Android app is in app/, and the network stack is split into rns-api, rns-backend-kt, rns-backend-py, rns-host, rns-ipc and rns-stats, with application logic in domain/. The build is Gradle with detekt for static analysis, and there are maestro and screenshot test directories.

## Sources

- [License: MPL-2.0](https://github.com/torlando-tech/columba/blob/main/LICENSE)
- [Project website](https://columba.network/)
- [README](https://github.com/torlando-tech/columba/blob/main/README.md)
- [Releases](https://github.com/torlando-tech/columba/releases)
- [torlando-tech/columba on GitHub](https://github.com/torlando-tech/columba)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/torlando-tech-columba