# Syncthing-Fork: the Android wrapper that replaced the discontinued official app

> Syncthing-Fork packages the Syncthing daemon inside an Android app, published on F-Droid and GitHub releases. It is a fork of the archived official Android client, and the README points at a wiki for migration and build notes.

**researchxxl/syncthing-android** — Syncthing-Fork - A Syncthing Wrapper for Android.

- Repository: https://github.com/researchxxl/syncthing-android
- Stars: 2,897 · Forks: 115
- Language: Java
- License: MPL-2.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/researchxxl-syncthing-android

## What Syncthing-Fork solves, and who it is actually for

Syncthing synchronises folders between devices directly, with no central server. On a desktop that is a binary you install and forget. On Android there is no shell to run it in, so somebody has to wrap the daemon, keep it alive across screen-off periods, and give it a user interface. That is the entire job of this project.

The audience is narrow but real. You run Syncthing on a laptop, a NAS or a home server, and you want a phone or tablet to be one more peer in that mesh. Photos taken on the phone land in a folder on the server. Notes written on the desktop appear on the phone. No account, no quota, no vendor holding the keys.

The README describes the project as 'A wrapper of Syncthing for Android' and directs users to the releases section or F-Droid for builds. It also asks people to seek help on the forum or social media before opening an issue on the tracker, which tells you something about the maintainers' support capacity. The repository is a fork of syncthing/syncthing-android, the official Android client that is now described as deprecated, and the README links a wiki article titled 'Switching from the deprecated official version'. If you are still on the official app, that migration path is the intended entry point.

## How the wrapper is put together

The repository layout is a standard Android Gradle project with one unusual directory: syncthing/. That is a git submodule holding the upstream Syncthing source, separate from app/, which holds the Android code. The wrapper does not reimplement the synchronisation protocol in Java. It builds the Go daemon and ships it, then talks to it.

That division explains most of the app's behaviour. Configuration, device IDs, folder definitions and the REST interface belong to the daemon. The Android layer contributes lifecycle handling, notifications, a settings UI and the foreground service that keeps the process from being reaped. When something goes wrong at the protocol level, the bug is upstream. When the app dies in the background, the bug is here.

The build tooling is visible at the top level: build.gradle.kts, settings.gradle.kts, gradle.properties, plus build.cmd, clean.cmd, lint.cmd and kill.cmd for Windows users. A scripts/ directory and a GitHub Actions workflow named build-app.yaml handle automation. The wiki has a 'Building and Development' article under wiki/developers/ for anyone who wants the full instructions rather than reverse-engineering the Gradle files.

Because the daemon is a submodule, the app's version number and the bundled Syncthing version move independently. Release tags such as v2.1.5.0 and v2.1.6.0-rc.1 track the wrapper, not necessarily the exact upstream commit a user is running.

## Installing Syncthing-Fork and pairing your first device

The README does not walk through installation. It says to head to the releases section or F-Droid for builds, and points at the wiki for migration and development detail. So the honest instruction is: get the APK from the GitHub releases page or from F-Droid, and if you are moving off the official app, read the wiki migration article first.

The F-Droid package identifier appears in the README badge links, and it is the string you search for in an F-Droid client:

```bash
com.github.catfriend1.syncthingfork
```

The README also provides an Obtainium link for users who prefer to track GitHub releases directly rather than wait for F-Droid. Obtainium's configuration in that link includes verifyLatestTag and an apkFilterRegEx of com.github.catfriend1.syncthingfork, which is what stops it from grabbing the wrong artifact.

Once installed, the app runs the daemon and exposes a device ID. The pairing flow is Syncthing's, not the app's: you add that device ID on your other machine, accept the incoming connection there, and then share a folder in both directions. Nothing in the README changes that protocol, and no README example shows a shortened version of it.

For developers building from source rather than installing a release, the repository ships Gradle wrapper scripts. On Windows the README's repository listing includes purpose-built helpers:

```bash
build.cmd
clean.cmd
lint.cmd
```

Those wrap the Gradle tasks; the wiki's Building and Development article is where the README sends you for the actual sequence and prerequisites.

## Where the wrapper model breaks down

The most common failure is not a sync bug. It is Android killing the process. Aggressive battery management on some manufacturers suspends background services, and a suspended daemon cannot answer peers. The README itself links a third-party project, SleepSync, described as pausing Syncthing-Fork when the device sleeps and resuming it on screen wake. That project exists because the default behaviour is not always what users want, and it is a signal about how much of this app's reliability depends on OS-level power policy rather than on the app's own code.

Second, the README is thin on operational detail. Installation, rollback, and what happens to your folder database across an upgrade are not documented in the README at all; they are deferred to the wiki. If you need a project where the front page answers those questions, this is not it.

Third, the fork carries the maintenance burden of a moving upstream. The daemon lives in a submodule, so wrapper releases and daemon versions can drift. A release candidate such as v2.1.6.0-rc.1 sits alongside stable tags like v2.1.5.0, and choosing between them is a judgement the README does not help you make.

Finally, this is Android only. The wrapper approach does not transfer to iOS, and the README lists no iOS counterpart.

## Syncthing-Fork versus the alternatives people actually consider

The comparison the search data keeps returning is syncthing fork vs syncthing android. The difference is not technical: the official Android client is described in this README as deprecated, and the fork exists to continue it. If you are choosing today, the fork is the maintained line and the official app is the one you migrate away from. The wiki article 'Switching from the deprecated official version' exists precisely for that move.

Against a cloud sync product, the difference is architectural. A hosted service stores your files on someone else's hardware and gives you a web interface and a support address. Syncthing-Fork stores nothing centrally; every device is a peer, and availability depends on at least two of your own devices being online at the same time. You trade convenience for the absence of a third party. You also trade away the ability to sync when only one device is awake, which is the failure mode people hit first.

Against running Syncthing on a small always-on server and reaching it from the phone over a web browser, the wrapper wins on background operation and loses on transparency: a browser tab shows you the daemon's own UI, while the app presents its own settings layer over the same REST interface.

The README's third-party list points at DecSync CC and Flym DecSync for contacts, calendars, tasks and RSS over the same decentralised model. Those are complements, not substitutes.

## Licence, maintenance and the cost of upgrading

The project is licensed under MPL-2.0, and the README links the LICENSE file. MPL-2.0 is file-level copyleft: modifications to covered files must be published under the same licence, while larger works that combine it with other code can carry other terms. If you are embedding this app or its build output in a commercial product, that is a question for your own counsel, not something this article can settle. The practical point for ordinary users is that the app is free to install and redistribute under those terms.

The repository is not archived, and the last push was on 2026-09-22, days before this article. Releases have been frequent: v2.1.3.0 on 2026-08-05, v2.1.5.0 on 2026-09-08, and a release candidate v2.1.6.0-rc.1 on 2026-09-15. That cadence is the upgrade cost. F-Droid builds lag GitHub releases, so if you want the newest tag you are either using Obtainium or sideloading APKs yourself.

The other upgrade cost is invisible in the README: because the Syncthing daemon is a submodule, an app update can move the daemon version underneath your existing configuration. The README does not document a rollback procedure, and the wiki is where any such guidance would live. Before upgrading a device that holds the only copy of a folder, confirm that copy exists elsewhere.

## Conclusion

Adopt Syncthing-Fork if you need continuous folder synchronisation between an Android device and your own machines without a cloud account, and you accept that the app is a wrapper around a separate Syncthing binary. Do not adopt it if you want a hosted service with a web dashboard, or if you need iOS. Before installing, check the wiki migration article if you are coming from the deprecated official app, and confirm your device's battery optimisation settings will not kill the background process. The package to look for on F-Droid is com.github.catfriend1.syncthingfork.

## FAQ

### Is the Syncthing Android app discontinued?

The README refers to the official version as deprecated and links a wiki article titled 'Switching from the deprecated official version'. Syncthing-Fork is the fork that continues it.

### Is Syncthing-Fork available on Android?

Yes. The README says to head to the releases section or F-Droid for builds, and the F-Droid badge points at the package com.github.catfriend1.syncthingfork.

### How to install Syncthing on Android?

The README does not give step-by-step install instructions. It directs users to the releases section or F-Droid for builds, and provides an Obtainium link for tracking GitHub releases.

### How to use Syncthing on Android?

The README describes the app only as a wrapper of Syncthing for Android and defers usage detail to its wiki knowledge base. The synchronisation itself is Syncthing's normal device-to-device model, not something the README re-documents.

### Does Syncthing still work on Android?

The README presents Syncthing-Fork as the current Android option, forked from the deprecated official client, with builds on the releases page and F-Droid and a recent release candidate v2.1.6.0-rc.1. The Android side is alive in this fork.

### syncthing fork vs syncthing android

The README calls the official version deprecated and links a migration article for switching away from it. The fork is the continuation, so the distinction is which one is still being built, not a difference in the sync protocol.

## Sources

- [Issues](https://github.com/researchxxl/syncthing-android/issues)
- [License: MPL-2.0](https://github.com/researchxxl/syncthing-android/blob/main/LICENSE)
- [README](https://github.com/researchxxl/syncthing-android/blob/main/README.md)
- [Releases](https://github.com/researchxxl/syncthing-android/releases)
- [researchxxl/syncthing-android on GitHub](https://github.com/researchxxl/syncthing-android)

---

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