Reticulum-Go

A high-performance and secure Go implementation of the Reticulum Network Stack.

Overview

Reticulum-Go provides full protocol compatibility with the Python reference implementation while leveraging Go's concurrency model for improved throughput and latency. The implementation targets cross-platform deployment across legacy and modern systems.

See COMPATIBILITY.md for how this is verified against the Python stack and the network API reference.

Features

Goals:

• Full protocol interoperability with the Python reference implementation
• Portability
• High performance via Go's concurrency model and best coding practices

Cryptography

Algorithms, key formats, storage, IFAC, and operational guidance are documented in docs/cryptography.md. Application code should use pkg/cryptography and pkg/identity rather than ad hoc primitives.

Requirements

• Go 1.26.2 or later

Quick Start

You can use the Makefile targets below or run the equivalent go commands directly if you do not have Make installed.

Build

make build

mkdir -p bin
CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/reticulum-go ./cmd/reticulum-go

Output: bin/reticulum-go

Install

Install to system path (default /usr/local/bin):

make install

mkdir -p bin
CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/reticulum-go ./cmd/reticulum-go
cp bin/reticulum-go /usr/local/bin/

Custom install prefix:

make install PREFIX=/opt/reticulum

mkdir -p /opt/reticulum/bin
mkdir -p bin
CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/reticulum-go ./cmd/reticulum-go
cp bin/reticulum-go /opt/reticulum/bin/

Alternatively, install into your Go toolchain binary directory ($GOBIN or $(go env GOPATH)/bin):

CGO_ENABLED=0 go install -ldflags="-s -w" ./cmd/reticulum-go

Run

make run

go run ./cmd/reticulum-go

Test

make test

go test -v ./...

Makefile Reference

Taskfile (Alternative)

The project also provides a Taskfile for extended automation. Install Task and run task --list for available targets.

task build
task install
task test

Note: On some systems, use go-task instead of task; add alias task='go-task' to your shell config if needed.

Development

Code Quality

make fmt
make vet
make lint
make check

go fmt ./...
go vet ./...
revive -config revive.toml -formatter friendly ./pkg/* ./cmd/* ./internal/*
go test -short -v ./...
go run golang.org/x/vuln/cmd/govulncheck@v1.1.4 ./...

Cross-Platform Builds

make build-linux
make build-windows
make build-darwin
make build-all

Cross-compilation uses GOOS and GOARCH with the same go build flags as make build; see Makefile build-linux, build-windows, and build-darwin targets for exact commands.

WebAssembly and Embedded

Build WebAssembly binary (requires Task):

task build-wasm
task test-wasm

For embedded systems and TinyGo builds, see the tinygo branch. Requires TinyGo 0.41.0+.

Vendored dependencies and offline builds

Why we vendor

Vendoring keeps the exact third-party source tree in this repository so builds and tests do not depend on fetching modules at compile time. That supports air-gapped and offline environments, avoids coupling releases to the availability of public module proxies or hosting sites, and makes the dependency set easy to review in diffs and audits. It is also central to supply chain security for dependencies: ordinary builds compile what is committed here, not whatever a proxy or upstream source might serve at build time, and changes to third-party code show up in review as normal source diffs. Dependency versions are still recorded in go.mod and go.sum; vendor/ is the canonical copy used for ordinary builds.

The Makefile and Taskfile default to GOFLAGS=-mod=vendor and GOPROXY=off, so a normal make build, make test, or task build / task test does not contact module proxies, the checksum database, or Git remotes for dependencies. Only the Go toolchain (and the standard library it ships with) is required besides this repository.

CI sets the same variables for build, test, and related jobs. Steps that install standalone tools with go install (for example revive, gosec, and govulncheck in scripts/ci/) temporarily clear those flags so the installer can fetch those binaries; project code still builds from vendor/.

When you change dependencies, use a network-enabled environment, run go mod tidy and go mod vendor, then commit go.mod, go.sum, and vendor/. The make deps and task deps targets use the public module proxy to download and verify modules for that workflow.

The examples/wasm tree has its own go.mod; it is not covered by the root vendor/ layout. Docker images under docker/ copy vendor/ and build with the same offline module settings.

Credit

Mark Qvist - For creating the Reticulum Network Stack

License

Apache License 2.0. See LICENSE.