A single-binary TAK server for ATAK and CloudTAK, secure by default.
rustak is a Team Awareness Kit server written in Rust. It speaks the same wire protocols as the official TAK Server — the Cursor-on-Target stream (XML and TAK Protocol v1), certificate enrolment, channels, data packages, device profiles and the Marti HTTP API — so ATAK-CIV devices and CloudTAK connect to it as they would to TAK Server. It ships as one binary with an embedded SQLite database and an embedded admin UI, and it is a clean-room implementation under the MIT licence: no code is shared with TAK Server or OpenTAKServer.
It is built for the deployments the official server is too large for — a family, a search team, a HAM radio club, a homelab — without giving up the security model a TAK deployment is supposed to have.
Status: pre-release. The CoT stream, enrolment, channels, data packages, device profiles, Data Sync (missions), ACME certificates, the CloudTAK login path, browser single sign-on and the sidecar API are implemented and covered by the interop suites below. There is no tagged release yet. Progress is tracked in
.claude/plan/plan.mdand the per-milestone notes under.claude/plan/status/.
Install with Homebrew (formula published with the first tagged release):
brew install sierrasoftworks/tap/rustakOr run the container image, published for linux/amd64 and linux/arm64 from every build of
main:
docker run -v $(pwd)/data:/data -p 8446:8446 -p 8443:8443 -p 8089:8089 \
ghcr.io/sierrasoftworks/rustak:latest # reads /data/config.tomlPre-compiled binaries for Linux (musl, static), macOS and Windows are attached to GitHub releases. The binary has no runtime dependencies: TLS is rustls, there is no OpenSSL, and the database is embedded.
- Encrypted, authenticated transport only. The CoT stream listens on TLS with a client certificate required; there is no plaintext TCP listener and no anonymous access. The Marti API listener requires a client certificate as well, and the public HTTPS listener exists for enrolment, the admin UI and CloudTAK.
- Built-in certificate authority and QR enrolment. rustak issues device certificates from its
own CA through the same
tls/configandsignClientflow ATAK uses. A device enrols with a one-time token rendered as atak://QR code in the admin UI; the token expires in fifteen minutes and is consumed on first use. Revoking a certificate ends its live sessions. - No passwords by default. Administrators sign in with passkeys (WebAuthn) or an OpenID
Connect provider; first-run setup is unlocked by a one-time token written to disk. The only
reusable secret is an opt-in, expiring client password minted explicitly for clients that need
one — CloudTAK's
/oauth/tokenpassword grant — and it is accepted nowhere else. rustak is also an OpenID Connect provider in its own right, with a discovery document, a key set, ID tokens and/oauth/userinfo, so a client can sign people in against it and enrol a certificate with the very same token. - Channels, contacts and data packages as ATAK expects them. Channel membership with IN/OUT
direction and per-device active state,
t-x-g-cchange notices, contact and client-endpoint listings, mission-package upload and download over/Marti/sync/*, andb-f-t-rrelay between devices. - Device profiles and config packages. Profiles deliver
.prefsettings and files on enrolment and on every connect; the server builds ATAK/WinTAK and iTAK connection packages from its trust store (POST /api/v1/config-packages) for devices that cannot use the QR flow. - CloudTAK as the map. rustak implements the exact response shapes CloudTAK's
node-takclient parses — theContent-Typeit compares byte for byte, the JWT layout it decodes by hand, thens2:certificateConfigdocument,/files/api/config— so CloudTAK can be pointed at it withssl://host:8089,https://host:8443andhttps://host:8446. - One process, one directory. State and metadata live in SQLite (WAL mode); file content is stored content-addressed on disk; CoT history is written to append-only, protobuf-framed segment files per device, so a busy stream never turns into a busy database. Back up the data directory and you have everything.
- Sidecar plugins in any language. A plugin is an ordinary authenticated TAK client with its
own certificate and channel scope. The
rustak-clientcrate provides a reconnecting stream, the Marti client and aSidecartrait;rustak-plugin-exampleis the template.rustak-plugin-ais(vessels, from an!AIVDMreceiver of your own or the AISStream.io feed),rustak-plugin-adsb(aircraft, from a localreadsbreceiver, a public aggregator or the OpenSky Network) andrustak-plugin-firms(active fires, from NASA FIRMS satellite detections) put open data feeds on the map through the same contract, andrustak-plugin-esbdoes the same for Irish power outages from ESB Networks' PowerCheck. - Compatibility proven in CI, not by hand. Every push runs a TypeScript suite against the
real
@tak-ps/node-takclient CloudTAK uses; nightly, ATAK's own networking core (commoncommo, built from source in a container) enrols, negotiates TAK Protocol v1, routes chat and transfers packages against a live server. - Observable. Structured logs and OpenTelemetry traces via tracing-batteries.
rustak takes one TOML file. Every key is documented with its default in
config.example.toml; a minimal configuration is:
[server]
name = "rustak"
domains = ["tak.example.com"]
data_dir = "/var/lib/rustak"
[web.public]
listen = [":8446"] # admin UI, /api/v1, enrolment, /oauth/token, Marti
[web.public.tls]
mode = "internal" # a certificate from the built-in CA; "files" for your own
[web.marti]
listen = ":8443" # Marti API, client certificate required
[stream.tls]
listen = ":8089" # the CoT stream, TLS with client certificates onlyValidate it, then start the server:
rustak --config config.toml --check
rustak --config config.tomlOn first start rustak creates its CA, writes a one-time setup token to
<data_dir>/setup-token and logs the path. Open https://tak.example.com:8446, enter the token,
register a passkey (or configure OIDC), and the wizard closes itself for good. From the admin UI,
create a user and mint an enrolment token: it is shown once, as a tak:// QR code. Scanning it
in ATAK's Quick Connect enrols the device and switches it to the encrypted stream. CloudTAK is
connected with one button — Onboard CloudTAK hands back the three URLs, a password and the
.p12 its Configure Server page insists on, as a one-shot download that expires in ten minutes;
it is the single place rustak generates a client's key, and it says so.
Docker, docker-compose with CloudTAK, a systemd unit, the TLS modes and backups are covered in
docs/deployment.md.
| rustak | TAK Server | OpenTAKServer | |
|---|---|---|---|
| Runtime | one static Rust binary | Java services | Python (Flask) plus RabbitMQ and nginx |
| Storage | embedded SQLite + append-only files | PostgreSQL | SQLite or PostgreSQL |
| Stream transport | TLS with client certificates only | TLS; plaintext TCP optional | TLS terminated by nginx; plaintext TCP optional |
| Admin sign-in | passkeys or OIDC, no local passwords | local accounts, LDAP, OAuth | local accounts, LDAP |
| Device enrolment | one-time QR token, built-in CA | password or token, external or built-in CA | QR token, built-in CA |
| Late-joiner state | latest position of every reachable device replayed on connect | replayed | not replayed |
| Licence | MIT | GPL-3.0 | see upstream |
TAK Server is the reference implementation and supports federation, video, plugins on the server side and much more; rustak deliberately does not. The comparison above reflects what each server does today, as read from its source; corrections are welcome.
Video streaming and recording, voice, server federation, QUIC transport, ExCheck and iTAK-specific behaviour are out of scope for now.
docs/deployment.md— configuring, running and backing up a server.docs/interop.md— the automated compatibility suites and how to run them.docs/compat/— manual compatibility checklists for ATAK, WinTAK, iTAK and CloudTAK: what a person checks by hand for a release, because CI can't run a real client's UI.docs/plugins.md— writing a sidecar withrustak-client.docs/ci.md— the CI/CD pipeline and how to reproduce every check locally.CONTRIBUTING.md— workspace layout, conventions and how to propose a change.
The workspace holds the server (rustak-server, the rustak binary), the protocol crate
(rustak-cot), shared DTOs (rustak-api), the foundations crate (rustak-core), the sidecar
SDK (rustak-client), the plugins (rustak-plugin-example, rustak-plugin-ais,
rustak-plugin-adsb, rustak-plugin-esb, rustak-plugin-firms) and the Yew admin UI (rustak-ui,
built with Trunk and embedded into the binary).
cd rustak-ui && trunk build && cd .. # the UI is embedded at compile time
cargo build # builds the rustak binary
cargo test --workspace # offline; fake EUDs, a test CA and an in-process IdP
cd rustak-ui && cargo test && cd .. # the UI's own tests: it is not in the workspace
cargo clippy --workspace --all-targets -- -D warnings
./scripts/check-file-length.sh # files stay under 300 functional linesATAK-CIV, TAK Server and OpenTAKServer were read for protocol facts only; nothing from them is
copied into this repository, and the ATAK-side test harness builds commoncommo at container
build time rather than vendoring it.