Skip to content
Fyndi docs
Polski

APK releases#

An APK release is one published build of the Android app. This page explains where to get it, how it is built, and what the version numbers mean.

Where to download the app#

The app is published under the fyndi.app domain, in the downloads directory:

WhatAddress
The newest buildhttps://fyndi.app/downloads/latest.apk
The release manifesthttps://fyndi.app/downloads/manifest.json
Older buildsthe same directory, by file name from the manifest
The release entry in the panelStaff panel → Releases — for staff: what is in the archive and what the phone sees on update

The user-facing channel is one place: the releases directory under the fyndi.app domain. The app reads the release manifest from it, compares the version and downloads a newer file. The version and size of the current release are also shown live in the footer of this documentation — they come from the server, so a new release needs no edit in the text.

The manifest is the source of truth for the app's own updater: it lists the releases with their tag, file name, size and publication date, and marks the newest one. The Settings → About the app screen in the app reads it, compares the version code with the installed one and installs the newer build. The same data is shown live on the website, so a number on a page is never a value typed in by hand (Installation, App updates).

How a release is made#

We build and publish releases on our own server, with one command, without a hosted build service and without a GitHub workflow. The repository is where the code and the version tags live — it is not a publication channel.

  1. The version is raised in the version file. android/app/build.gradle.kts holds a list of pairs of versionCode / versionName; the pair with the highest versionCode is what goes into the APK, and the order of the entries does not matter. The number never goes backwards and never repeats.
  2. bash scripts/build_release_apk.sh makes the whole release. It runs the JVM tests (:core, :ar, :app), builds the release variant and signs the file with the release key. On the way it passes its own gates: the signature must not be a debug key, and the ARCore key and the Mapbox token must be embedded in the app. Finally it runs an ART smoke test on the emulator (installing the APK and starting the AR markers screen) — a VerifyError or FATAL EXCEPTION in the log stops the release.
  3. Publishing is one operation. The script copies the APK to the releases directory, rewrites manifest.json (with the SHA-256) and latest.apk, puts the tag vX.Y.Z on the release commit and verifies its own release over HTTPS — downloading the file from the public address and comparing the size, checksum and the version read from the APK manifest.
  4. The phone sees the new version at the next update check: Settings → About the app.

The emulator has to be shut down before the build — the host that runs production shares memory with the build, and the build process leaves no daemon running behind it.

Signing and the release key#

Every APK is signed with a release key that lives on the server, outside the repository, in a directory that only the host account can read. The key is never committed, and it is not stored in any external service's secrets.

ItemValue
OwnerCN=Fyndi release
Sincethe first releases published from our own server; earlier versions were signed with a key under a different name
Where it liveson the server, in a mode-600 secrets directory, plus a copy kept by the owner

Why it matters to a player:

  • The signature is the same between versions, so a newer release installs on top of the older one — no uninstalling, no losing data.
  • Changing the key would break that chain. Historically, the first install after a key change required removing the old app once; that is why the key is treated as something to preserve, and why a copy of it outside the server is a condition of continuity.
  • Nobody can fake an update. The system only accepts an update signed with the same key, so a file from an unknown source cannot be installed over the app.

Version numbering#

Two numbers describe the same build, and both are needed:

  • versionName — the version a human reads, like 0.347.0; it is also the release tag.
  • versionCode — a plain integer that grows by one with every release, like 515. Phones compare only this number, so it must never repeat and never go backwards.

The versionCode / versionName pairs live in one place — android/app/build.gradle.kts — and only one of them reaches the APK: the one with the highest number. The version number never goes backwards and never repeats: a new release always gets a number higher than anything already published. One number = one release, so the same number can never describe two different files. A version gate (tools/ci/check-release-version.py) enforces this: before the build it says which pair really goes into the file and refuses to build when the file holds a higher pair than the one being built or the number goes backwards against the manifest; after the build it checks the number in the produced APK. The release script applies the vX.Y.Z tag itself.

Small fixes are collected into one release: a new release is the complete set of changes from a given day, not a separate release after every fix. The user-facing changelog is on the Changelog page, and the full technical record stays in the repository.


Documented for app version 0.357.3 (updated 2026-11-12).

Machine translation — the Polish version prevails.

App version: 0.357.3 API version: 0.73.0

docs.fyndi.app · 2026-11-12