Draw a bridge from a source to its destinations. The moment a row changes, it is written everywhere you linked — any engine to any other.
curl -fsSL https://syncle.dev/install | sh -s -- upOne bridge, several destinations at once — and bridges chain.
How a bridge fires
Three ways of noticing that something changed. Pick per bridge — the rest of the pipeline is identical.
One shot
Stream all — or a filtered slice — of the source once, then finish. The right tool for an initial backfill or a migration.
Polled
Follow a cursor: an auto-increment id, an updated_at column, or a primary-key diff. New rows sync as they appear, on every engine.
Real time
Read the change log itself — Postgres logical replication, MySQL binlog, MongoDB change streams, Redis keyspace notifications.
Customers → Replica
shop.customers → shop_replica.customers
Delivered
12,480
Failed
0
Skipped
3
Success
100%
| id | name | city | plan | took | |
|---|---|---|---|---|---|
| 5 | Edsger Dijkstra | edsger@example.com | Rotterdam | Pro | 45ms |
| 6 | Barbara Liskov | barbara@example.com | Boston | Enterprise | 3ms |
| 7 | Donald Knuth | don@example.com | Stanford | Team | 2ms |
| 8 | Margaret Hamilton | margaret@example.com | Boston | Pro | 2ms |
| 9 | Grace Hopper | grace@example.com | Arlington | Pro | 4ms |
What makes it trustworthy
The hard half is moving it exactly once, in the right shape, and noticing when a row disappears.
Writes are idempotent upserts keyed by the columns you choose, so replays, retries and redeliveries never double-write.
Inserts, updates and deletes all cross the bridge, each tagged with its operation — not just the rows that happen to be new.
If the destination doesn't exist, Syncle builds it from the source's shape, translating types across engines.
Write this column into that column over there — or design a payload and POST it to an HTTP endpoint instead.
Get started
It downloads the newest release, starts it, and opens the interface. No Node, no Postgres, no Redis to install — they all run in containers.
curl -fsSL https://syncle.dev/install | sh -s -- upThe image is pulled prebuilt for your architecture — Intel or ARM, macOS or Linux. Nothing compiles.
Syncle opens with a one-time setup token already filled in, proving you operate the machine.
Pick a source table and its destinations, then start it. Backfill first, then leave it listening.
Then, day to day
What people use it for
Every one of these is the same primitive — a source, some destinations, and a trigger — pointed at a different problem.
Backfill every row into the new database with a replay job, then leave a CDC bridge running so the two stay identical while you cut traffic over. Nothing has to be offline for it.
Keep a second database in step for reporting or exports without pointing analysts at production, and without paying for managed replication you cannot shape.
Project rows straight into Redis as they change, keyed however you like, so the cache is never the thing that went stale. Deletes remove the key rather than leaving it to expire.
Mirror the columns a search index needs into MongoDB or a flat table, reshaped on the way across, without bolting write hooks onto the application.
Carve a table out to a new service database and keep both in sync while callers move over one at a time, instead of coordinating a single risky switch.
Send each change to an HTTP endpoint with a payload you design, with retries and backoff, when what you need fed is an API rather than another store.
Where it sits
Airbyte and Debezium are built for teams running pipelines as a discipline. Syncle is for one person who wants two databases to agree.
| Aspect | Syncle | Airbyte | Debezium |
|---|---|---|---|
| To get running | One command | Kubernetes or Docker Compose | Kafka and Connect |
| Moving parts | Four containers | A platform | A broker and a cluster |
| Real-time capture | Built in, per bridge | On some connectors | The whole point |
| Writes to the destination | Direct, idempotent upserts | Through its own staging | You write the consumer |
| Interface | Web GUI, no config files | Web GUI | Config and code |
| Aimed at | One operator | A data team | A platform team |
Not a knock on either — if you already run Kafka, Debezium is the right answer. This is for everyone who does not.
Your data, your machines
A sync tool sees every row it moves and holds the credentials to both ends. That earns some scrutiny.
Syncle runs on your machine and talks to your databases directly. There is no account, no telemetry, and no third party in the path — the rows go from your source to your destination and nowhere else.
Saved connection details are sealed with AES-256-GCM under a key generated at install, which stays on the host. Losing the key costs you the stored secrets rather than exposing them.
The admin account is created with a one-time token printed on the server, so an instance reachable before you set it up cannot be claimed by whoever finds it first. Login is rate limited.
Connect through a bastion to databases that never listen on a public interface, so nothing has to be exposed to make a bridge work.
Questions
PostgreSQL, MySQL and MariaDB, SQLite, MongoDB and Redis — in any combination. A relational source can write into a document or key-value store and back, with values translated to fit the target. HTTP endpoints work as a destination too, when you are feeding a service rather than a database.
Both, and you choose per bridge. CDC reads the database change log directly — Postgres logical replication, MySQL binlog, MongoDB change streams, Redis keyspace notifications — so changes arrive with no polling. Watch polls a cursor instead, which works on every engine. Replay is a one-shot pass for the initial backfill.
Writes are idempotent upserts keyed by the columns you pick, so a replay, a retry or a redelivery rewrites the same row rather than adding another. Deletes propagate as deletes. Jobs record their cursor as they go, so an interrupted run resumes where it stopped instead of starting over.
Docker, and nothing else. Node, PostgreSQL and Redis all run in containers, and the application image is pulled prebuilt for your architecture, so nothing is compiled on your machine. One command installs it, starts it and opens the web interface.
It is MIT licensed and entirely self-hosted. It runs on your own machine against your own databases; there is no account, no telemetry and no third-party service in the path. Stored connection credentials are encrypted with a key that never leaves your install.
Scale of setup. Airbyte expects Kubernetes and a team to operate it; Debezium expects Kafka. Syncle is a single command, four containers and a web interface, aimed at one operator who wants two databases kept in step without standing up a data platform first.
curl -fsSL https://syncle.dev/install | sh -s -- up