Self-hosted service
syncyomi/syncyomi avatar
syncyomi/syncyomi

SyncYomi's systemd guide names two different unit files

SyncYomi is an open-source project crafted to provide a seamless synchronization experience for your TachiyomiSY/Mihon (Mihon client is not implemented but it works the same probably will never be implemented)/manga reading progress and library across multiple devices.

749 stars41 forksGoGPL-2.0

At a glance

What is it?
SyncYomi is a self-hosted Go server that keeps TachiyomiSY and Komikku reading progress in step across devices, with PostgreSQL or SQLite behind it. Its install page is where the interesting details sit: a systemd walkthrough that names two different unit files, a `make build` that installs a global npm package with sudo, and a compose file in the repository that is a developer stack rather than the one the page hands you.
Who is it for?
SyncYomi is worth a look if you self-host a TachiyomiSY or Komikku library and want one server behind a reverse proxy with PostgreSQL rather than a hosted sync service. Leave it alone if you are on Mihon, because the project's own summary says that client is not implemented, and do not expect a documented release history, since the tags are the only record and the default branch is develop.
Can I use it commercially?
Yes, with conditions. GPL-2.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • syncyomi/syncyomi749 ★ · +39
Star history
Repository2026-09-112026-11-15
syncyomi/syncyomi710749

39 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The systemd walkthrough names syncyomi.service and creates [email protected]

The Linux service section tells you to create a file in `/etc/systemd/system/` called `syncyomi.service`, then hands you a command that creates `[email protected]`, a templated unit with an instance slot. The unit body settles the question, because it uses `%i` where a plain unit would have nothing to expand: `User=%i`, `Group=%i` and an `ExecStart` pointing at `/home/%i/.config/syncyomi/`. A third inconsistency follows, since the enable command runs as the user manager while the file was placed in the system directory:

bash
touch /etc/systemd/system/[email protected]
bash
systemctl enable -q --now --user syncyomi@$USER

The `After=` line orders the unit behind `network-online.target` without pulling that target in, and `[Install]` asks for `multi-user.target`, which is a system manager target. None of that blocks startup, but a reader following the page literally ends up with a file the running systemd will not read.

make build starts by installing a global npm package with sudo

The Linux generic section offers two routes: a release binary, or build it yourself with `make build`. The second route is not self-contained. The `deps` target that `build` depends on runs `sudo npm install -g pnpm`, then `cd web && pnpm install`, then `go mod download`. So a from-source build of a Go server asks for root access to install a Node package manager on the host, and it does that before compiling anything. The container recipe avoids the problem by a different route, enabling corepack inside the image instead. Two other things sit in the same file: the header declares `.PHONY: test proto proto-check`, but no `test` target exists anywhere in it, and `install` copies the binary to `/usr/local/bin` while the systemd unit expects `/usr/bin/syncyomi`.

The compose file in the repository is a developer stack, not the published image

The page hands you a single-service compose file pulling `ghcr.io/syncyomi/syncyomi:latest`, with a `TZ` variable, an optional log volume and a host port mapping you may need to move. The compose file actually committed to the repository is a different thing: it runs `syncyomi:dev`, which is the tag `make build/docker` produces locally, and it adds a `postgres:15.1-alpine` service with `POSTGRES_USER=SyncYomi` and `POSTGRES_PASSWORD=SyncYomi` set to the project name, publishing `5434:5432` on the host. An inline comment explains why the database is dedicated rather than the default one, since the app creates its own tables on Postgres 15 and up. Useful as a local stack, and a poor thing to copy onto a host, since that database port is bound without a certificate authority, a secret or an interface restriction. The page's own file also still carries a `version` key, which Compose v2 reads as legacy.

The link labelled source code points at the releases page

On Linux you are told to download the latest release, or to download the source code and build it yourself. The words source code are a link to `https://github.com/SyncYomi/SyncYomi/releases/latest`, which is the same releases listing, not an archive of the source tree. The one-line downloader beside it is narrower still, since it greps the API response for `linux_x86_64` and nothing else:

bash
wget $(curl -s https://api.github.com/repos/SyncYomi/SyncYomi/releases/latest | grep download | grep linux_x86_64 | cut -d\" -f4)

The feature list advertises ARM alongside x86, and nobody on an aarch64 box can use that line. Releases are moving fast on the 1.5 line, v1.5.6 on 2026-09-19, v1.5.7 on 2026-09-25 and v1.5.8 on 2026-09-28, with the most recent push on 2026-10-02. Releases are automated through release-please, which is why `CHANGELOG.md`, `release-please-config.json` and `.release-please-manifest.json` all sit at the root, and the default branch is `develop` rather than `main`.

One API key is one user, and devices that disagree become strangers

The API key section carries the sharpest warning on the page. Each key is a user identity: devices presenting different keys are treated as separate users, each with its own syncing data, so a library that fails to converge is often just two devices holding two keys. Keys are generated in the web interface at `http://<your-server-address>:8282` under Settings, then pasted or scanned as a QR code into the client. That makes the key the only credential in the system and gives it two jobs at once, which is worth remembering before sharing a server with a household. The feature list adds notifications through Discord, Telegram, ntfy and Notifiarr on top, so the key also unlocks outbound delivery to whichever of those you configure.

Mihon is named in the summary as a client that will not be built

The project's one-line summary describes synchronization for TachiyomiSY, Mihon and manga readers generally, then parenthesises that the Mihon client is not implemented, that it works the same, and that it probably never will be. The installation notes agree in practice by naming only TachiyomiSY and Komikku as the apps to install, and by telling you to take a manual backup first through More, Data and storage, Create backup. In the client the Sync option moves from Off to SyncYomi and the host is filled in as a URL plus key, either a domain behind a reverse proxy or a bare address on the local network. Read the summary's parenthetical as the deciding fact: if your reader is Mihon, no amount of server-side configuration reaches it.

The config path changes three times and the default bind is loopback only

The binary takes `--config`, but the three documented paths all set it differently. The systemd unit uses `/home/%i/.config/syncyomi/`, the container entrypoint uses `--config /config`, and the plain Windows and generic Linux instructions just say to run the binary, which leaves the generated files in the working directory. First run writes several files into that directory, and `config.toml` is where the listen address lives. The default is `127.0.0.1`, with a reverse proxy such as caddy, nginx or traefik recommended in front; without one, `host` has to be changed to `0.0.0.0`. For finding the address to put in the client, the page gives one command:

bash
ip -4 addr show | grep -oP '(?<=inet\s)\d+(\.\d+){3}'

Subfolder deployments are handled by setting `baseUrl` and letting the proxy strip the suffix. The nginx sample sets `X-Forwarded-Host` but not `X-Forwarded-Proto`, so anything that depends on the scheme needs adding yourself. The Usage section also opens a heading, Configuring and Running the Service, with nothing under it.

CGO-free SQLite, and an SSE dependency pointed at a 2023 fork snapshot

go.mod asks for Go 1.26.0 and pulls `github.com/lib/pq v1.12.3` for PostgreSQL alongside `modernc.org/sqlite v1.60.0` for SQLite, the pure Go driver, which is consistent with a Dockerfile that notes it cross-compiles natively on the build host with CGO disabled. The container is built from `golang:1.27-alpine3.23` and `node:26-alpine`, so the image builder is a version ahead of the declared floor, and there is a `.node-version` file pinning the frontend separately. The dependency worth a second look is `replace github.com/r3labs/sse/v2 => github.com/autobrr/sse/v2 v2.0.0-20230520125637-530e06346d7d`, which redirects a required v2.10.0 to a fork snapshot from 2023-05-20. Server-sent events carry the notifications the feature list promises, so that pinned commit is on the path of every Discord, Telegram, ntfy and Notifiarr message the server sends.

Editorial conclusion

SyncYomi is worth a look if you self-host a TachiyomiSY or Komikku library and want one server behind a reverse proxy with PostgreSQL rather than a hosted sync service. Leave it alone if you are on Mihon, because the project's own summary says that client is not implemented, and do not expect a documented release history, since the tags are the only record and the default branch is develop. Before you rely on it, fix the systemd unit by hand to match `[email protected]` and your own config path, confirm `make build` works without `sudo` on your box, and check whether you meant the GHCR image or the local `syncyomi:dev` image.

Frequently asked questions

What is SyncYomi and what does it synchronize?

SyncYomi is a self-hostable Go server for keeping Tachiyomi reading progress and a library in step across devices. It ships a mobile-oriented web UI, runs on PostgreSQL or SQLite, and sends notifications through Discord, Telegram, ntfy and Notifiarr.

Does SyncYomi work with Mihon?

The project's own summary states the Mihon client is not implemented, adding that it works the same way and probably never will be implemented. The installation notes name TachiyomiSY and Komikku as the apps to configure, and both are linked from the page.

How do I install SyncYomi on Linux?

Download a release binary from the releases listing, or run `make build`, whose `deps` target starts with `sudo npm install -g pnpm` before building the web assets with pnpm and the binary with go. The service listens on `127.0.0.1` by default.

What happens if I use two different API keys?

Each key counts as a unique user, so devices presenting different keys are treated as separate users with their own syncing data. Every device meant to synchronize has to use the same key, generated under Settings in the web interface on port 8282.

Which databases can SyncYomi run on?

PostgreSQL and SQLite. go.mod carries `github.com/lib/pq v1.12.3` and `modernc.org/sqlite v1.60.0`, the pure Go SQLite driver, and the Dockerfile states it cross-compiles natively on the build host with CGO disabled.

Can I run SyncYomi behind a reverse proxy in a subfolder?

Yes. Base path, subfolder and subdomain support are listed among the features, the setting is `baseUrl`, and the page shows an nginx location block for `/syncyomi/` that rewrites the prefix away before proxying to `http://127.0.0.1:8282`. The proxy has to strip the suffix as well as pass the prefix along.

Official sources

  1. Issues
  2. License: GPL-2.0
  3. README
  4. Releases
  5. syncyomi/syncyomi on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/syncyomi-syncyomi.svg)](https://hysenlabs.com/projects/syncyomi-syncyomi)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/syncyomi-syncyomi.svg)](https://hysenlabs.com/projects/syncyomi-syncyomi)

Was this useful?