Self-hosted update server for desktop apps β your release pipeline, fully under your control.
Spin up the API with MongoDB, Redis, and a preconfigured S3-compatible storage (Garage) β no cloud account required:
git clone https://github.com/ku9nov/faynoSync.git
cd faynoSync
docker compose up --build # API + MongoDB + Redis + Garage + Dashboard
docker compose exec -T backend /usr/bin/faynoSync migrate up # run after the stack is healthyThe API is now live at http://localhost:9000. Check for an update from any client:
curl "http://localhost:9000/checkVersion?app_name=myapp&version=0.0.1&owner=admin"Upload builds and manage versions via the dashboard served by the API at http://localhost:9000/dashboard/ or the REST API. Full setup, env vars, and self-build instructions are below.
faynoSync is a self-hosted, open-source API server for managing and updating cross-platform desktop applications (Windows, macOS, Linux). It enables automatic and on-demand updates for client software, making it easy to deliver new versions to users through a customizable update workflow.
The server allows developers to upload application builds to S3, set version metadata, and expose a simple REST API for clients to check for updates. When a client queries the API, it receives version information and a download URL if an update is available.
faynoSync supports both background updates and manual update prompts, depending on how the client integrates with the API. This gives developers full control over how and when updates are delivered to end-users.
Itβs ideal for managing updates in Electron apps, native desktop applications, or any cross-platform software where you want full control over versioning, distribution, and update channels (e.g. stable, beta, nightly).
| Category | Technology | Description |
|---|---|---|
| API Framework | Go (Golang) | Main application server built with Go |
| Database | MongoDB | Primary database for storing application metadata, users, and configurations |
| Cache & Performance | Redis | Required. Caching, statistics, TUF task state, rate limits |
| Updaters | electron-builder | Update feeds for Electron apps (auto-generated latest*.yml / latest-mac.yml) |
| Tauri | Updater for Tauri apps (signature-based verification) | |
| Squirrel | Update support for Squirrel.Windows and Squirrel.Mac | |
| Velopack | Cross-platform installer/updater framework | |
| Sparkle | macOS-only installer/updater framework | |
| Manual | Direct download without a framework-specific update feed | |
| Storage | S3-Compatible | Supports multiple cloud storage providers: |
| AWS S3 | Amazon Web Services Simple Storage Service | |
| Garage | Recommended local S3-compatible storage, used via the AWS SDK | |
| MinIO | Deprecated local S3-compatible storage option that still works but is no longer maintained | |
| Google Cloud Storage | Google Cloud Platform storage service | |
| DigitalOcean Spaces | DigitalOcean's S3-compatible object storage |
- Repository: faynoSync-site - Source code for documentation
- Live Documentation: faynoSync Documentation - Online documentation
- The web dashboard lives in
dashboard/and is embedded into the API binary, which serves it at/dashboard/. SetDASHBOARD_ENABLED=falseto turn it off.
You can find examples of client applications here.
- Examples Directory: Client Application Examples - Various client implementations
- Postman Collection: faynoSync.postman_collection.json - Ready-to-use API requests
- API Documentation: API Reference - Complete API reference
To build this application from source, you will need Go and, for the embedded dashboard, Node.js with Yarn. Install Go from the official website.
-
Install Go: Download and install from golang.org
-
Clone Repository: Once you have installed Golang, clone this repository to your local machine:
git clone https://github.com/ku9nov/faynoSync.gitAll settings are environment variables. .env.example lists every variable with a one-line description and working values for local development; the full reference is the Environment Variables Overview.
- Running the API from source:
cp .env.example .env. The API reads.envfrom its working directory, and environment variables take precedence. - Docker Compose reads
.env.exampledirectly and overrides only the service hostnames (see thebackendservice indocker-compose.yaml).
For local development the recommended storage is Garage with the aws storage driver: Garage is the S3-compatible backend, and uploads and downloads go through the AWS SDK. The Docker Compose setup creates the buckets and imports the credentials from .env.example automatically.
Garage admin UI is available at http://localhost:3909/ (user: admin, password: BjjctVsoSg4FKkT81VKt18).
The dashboard is available at http://localhost:9000/dashboard/. For hot reload while working on it, run yarn dev in dashboard/: it serves on http://localhost:3000/dashboard/ and proxies API requests to http://localhost:9000. Run yarn build there before go build to embed it into a binary you build yourself.
To build and run the API with all dependencies (Local Setup β Docker Compose), use the following command:
docker compose up --buildYou can run migrations using this command after docker compose up --build finishes:
docker compose exec -T backend /usr/bin/faynoSync migrate upYou can now run tests using this command after docker compose up --build finishes and the storage service becomes healthy:
docker exec -it faynoSync_backend "/usr/bin/faynoSync_tests"If you only want to run dependency services (for local development without Docker), use this command:
docker compose up -d db cache s3 webuiNaming the services starts only them (and their dependencies), so backend stays down and you can run the API and dashboard from source while MongoDB, Redis, and Garage stay containerized. docker compose down stops them as usual. Step-by-step guide: Local Setup β from source.
To use the auto updater service, follow these steps:
cd dashboard && yarn install && yarn build && cd ..
go build -o faynoSync .Skipping the dashboard build still produces a working API, but /dashboard/ returns 503.
- Start API Server:
./faynoSync- Run Migrations (after API health check):
./faynoSync migrate up- Rollback Migrations (if needed):
./faynoSync migrate down- Upload your application to S3 and set the version number in the dashboard (
/dashboard/) or using API. For large builds, skip the reverse proxy and upload straight to storage with presigned URLs:POST /upload/initβPUTβPOST /upload/complete, see Presigned Uploads.
- In your client application, make a GET request to the auto updater service API, passing the current version number as a query parameter:
http://localhost:9000/checkVersion?app_name=myapp&version=0.0.1&owner=admin&channel=stable&platform=linux&arch=amd64
The auto updater service will return a JSON response with the following structure:
{
"update_available": true,
"update_url_deb": "https://<bucket_name>.s3.amazonaws.com/myapp-admin/stable/linux/amd64/myapp-0.0.2.deb",
"update_url_rpm": "https://<bucket_name>.s3.amazonaws.com/myapp-admin/stable/linux/amd64/myapp-0.0.2.rpm",
"changelog": "### Changelog\n\n- Added new feature X",
"critical": false
}Each artifact is returned as update_url_<ext> (update_url_dmg, update_url_deb, ...), or as update_url when the file has no extension. Response formats for every updater are in Check Latest Version.
- In your client application, show an alert to the user indicating that an update is available and provide a link to download the updated application.
go testgo test -c -o faynoSync_tests# Optional: set MONGODB_URL_TESTS for tests that require a MongoDB connection
# export MONGODB_URL_TESTS=mongodb://root:MheCk6sSKB1m4xKNw5I@localhost/cb_faynosync_db_tests?authSource=admin
go test ./server/... -raceTest Descriptions
To successfully run the tests and have them pass, create the .env file from .env.example.
The tests verify the implemented API using a test database and an existing S3 bucket.
Install migrate tool here.
cd mongod/migrations
migrate create -ext json name_of_migrationThen run migrations with the built-in command:
./faynoSync migrate up- Migration Tool: golang-migrate - Database migration utility

