DecSync (“decentralized synchronization”) is a free and open source decentralized synchronization tool for synchronizing certain data between devices without a server. As of March 15, 2023, there are DecSync implementations for RSS feeds, contacts, calendars, tasks, and OSMand (Android application) data. Synchronization works by sharing the DecSync directory between devices with the requisite packages and applications installed. While there are different ways to sync the DecSync directory, the method most in line with the unique points of the protect is Syncthing (or a similar tool), which syncs the directory between devices (each device is a peer) without a central server. Ordinarily, trying to sync something like an RSS reader database with Syncthing would lead to conflicts if changes occur on both peers simultaneously. DecSync’s implementation works to avoid these conflicts.

I have personally used DecSync to sync RSS feeds, contacts, tasks, and calendars, and I confirmed that the OSMand implementation works as well. Because DecSync is a very interesting and valuable project, I decided to share it here at The New Leaf Journal and explain why it is important and how I hope it can be built upon in the future.

Technical details

I always preface my discussion of the technical details of something like DecSync by noting that I am neither a developer nor a programmer. I have a surface level understanding of how DecSync works and practical experience using it, but I am not well-qualified to explain it in a very technical way beyond pointing you to the detailed documentation created by its main developer, Mr. Aldo Gunsing.

DecSync is a free and open source project maintained by Mr. Gunsing. The source code is available on GitHub.

The DecSync Readme describes it as follows:

DecSync (Decentralized Synchronization) synchronizes RSS, contacts, calendars, tasks and more without requiring a server.

How does it accomplish this?

It uses a synchronized directory to synchronize the data. This can be done without a server by using for example Syncthing, but any other method like Google Drive or Dropbox works.

In short, DecSync’s files exist within a directory (or folder). You can synchronize this directory across multiple devices. I will explain how I use Syncthing to accomplish this, but cloud storage tools such as Google Drive and Dropbox also serve as centralized alternatives for syncing the DecSync directory. Syncthing and similar peer-to-peer synchronization tools take full advantage of the fact that DecSync does not require a central server (compare with Dropbox, Google Drive, and the like, which combine DecSync with a central server).

The Readme notes that DecSync can be extended: “DecSync can also be used to synchronize custom key-value mappings, but currently synchronization of RSS, contacts, calendars, tasks and memos is implemented…”

In order to add DecSync functionality to a new application, developers can use libdecsync, a free and open source multi-platform library. (Users of Arch-based Linux distributions can install it from the Arch User Repository.)

Platform limitations

Do note that most of the DecSync implementations are focused on working on Linux and Android. Moreover, I have only tested DecSync on Linux (primarily Arch-based distributions) and two Android forks (LineageOS and /e/ OS). I have no personal knowledge of or experience with how it may or may not be possible to run existing DecSync implementations on other operating systems such as Windows, MacOS, iOS, BSD, or the like.

Using Syncthing to sync the DecSync directory

I explained above that using DecSync requires syncing a DecSync directory across devices. That is, all DecSync information, for example contacts, tasks, calendars, and your list of RSS feed subscriptions with starred articles and read-states, is stored within a single directory (otherwise known as a folder). This directory has sub-directories (or sub-folders) for the various components, e.g., feeds, tasks, calendars, etc. Applications that work with DecSync read and modify the relevant DecSync sub-directory.

I personally use Syncthing, a free and open source peer-to-peer syncing solution, to sync my DecSync directory. While one could use Dropbox, Google Drive, or any other centralized solution (including self-hosted cloud storage solutions such as Nextcloud or Seafile), I think that DecSync is best-used with Syncthing. With respect to a solution like Google Drive or Dropbox, one of the benefits of DecSync is keeping full control of your data. If you are willing to use a third-party proprietary solution, there are easier solutions available. The same applies but for different reasons to something like a self-hosted Nextcloud set-up. Nextcloud, and some other alternatives, have centralized solutions for syncing contacts, tasks, calendars, and feeds. With that being said, DecSync does have some advantages that could make it work for this set-up, but I think its main benefit comes when implemented with Syncthing. The DecSync developer evidently agrees. The DecSync CC app for Android (more on this below) invites the user to install Syncthing during app set-up with the following message:

DecSync CC works with any file synchronization service, but using Syncthing is recommended as data stays on your devices.

DecSync CC set-up

While I will not write a full guide to Syncthing, I will explain briefly how it works in the context of DecSync.

Syncthing syncs directories, or folders, directly between two devices. For example, let us say one wants to sync his or her DecSync directory between a desktop computer, laptop, and tablet. First, the person must install Syncthing on all three devices. Second, the person must, through Syncthing’s UI, add the other two devices to each device as a peer. Third, the person must then add the DecSync directory from one device to Syncthing and share it with the other two devices.

In order for Syncthing to sync between one or more devices, all of the devices must have Syncthing running. For example, if both the desktop and phone have Syncthing on and running, the DecSync directory will be synced continuously between them. The laptop would not receive the updates until it is on and has Syncthing running at the same time as at least one of the other two devices. Syncthing is somewhat limited by this requirement, but the issue can be ameliorated if you have at least one peer (device) that is always on with Syncthing running to receive and send along updates. In my case, I have an old laptop at home that is generally always on with Syncthing running.

(Note of caution: Make sure that you do not delete the hidden .stfolder in the DecSync Syncthing directory. Some Android cleaners on F-Droid can be configured to delete empty folders. At a minimum, you must exempt DecSync’s .stfolder if you are using Syncthing.)

Syncthing is somewhat user-friendly in that it has a robust web UI (running on localhost) for managing devices, synced directories, and settings for each directory. However, there are various points to be aware of before using Syncthing on important directories. For example, it would be ill-advised to use Syncthing to sync the databases of two RSS reader applications between two devices due to how their databases work and Syncthing’s limitations in handling those sorts of database conflicts.

In short, Syncthing allows you to keep all of your DecSync data “in house” or, at a minimum, limited only to those devices you control with Syncthing running. Syncthing is a very useful tool outside of DecSync and I recommend looking into it if you do not already use it. It is generally available for all major (and most niche) operating systems except iOS (Syncthing works on MacOS, but not iOS).

My use of DecSync

I currently used DecSync to synchronize contacts, tasks, and calendars among several devices running Linux and forks of the Android Open Source Project. I previously used DecSync to synchronize my RSS feeds, starred articles, and read-state for more than a year.

At the moment, I sync the DecSync directory among several computers running EndeavourOS (an Arch-based Linux distribution), Fedora Linux, Bodhi Linux (an Ubuntu-based Linux distribution), and GNU Trisquel (a Debian-based Linux distribution). I also sync to mobile devices running LineageOS and Android. However, I only have DecSync-powered applications installed on two of my computers running EndeavourOS and my phone, which runs LineageOS.

Having now used DecSync for more than one year, I will use my own experiences to inform my discussion. However, depending on your systems and set-up, your DecSync experience may vary.

DecSync for Contacts, Tasks, and Calendars

The most polished DecSync implementation is for contacts, tasks, and calendars. It is very easy to set up on mobile devices, but a bit more finicky on Linux computers. Mr. Gunsing has published the official specification for DecSync contacts and calendars.

DecSync CC for Mobile

There is a free and open source application for Android and Android-based devices called DecSync CC. This application is available from the open source F-Droid application repository and from GitHub.

The most recent version of DecSync CC (Version 2.2.3 (35), released on January 2, 2022) requires Android 5.0 or newer. I have used it on LineageOS, a fork of Android, and /e/ OS, a fork of LineageOS. I note additionally that DecSync CC should work on modern versions of Amazon’s Fire OS, which it uses for its Kindle Fire line of tablets (Fire OS is a proprietary fork of Android, thus allowing it to run most apps available on F-Droid).

Upon installing DecSync CC, the app walks users through set-up. The app will ask the user to choose a DecSync directory – this can either be a new directory or, in the case of a user who already has a DecSync directory, the pre-existing directory.

After completing set up, the user will be taken to a page wherein he or she can manage address books (contacts), calendars, and task lists.

Screenshot of DecSync CC app with address book, calendar, and task lists added.
I really ought to rename that last one…

One notable feature is that DecSync CC makes it easy to manage more than one address book, calendar, or task list. Note, however, that I only use it to manage one of each.

DecSync CC can handle multiple DecSync directories.

Adding a DecSync directory in DecSync CC.
I have not added a second DecSync directory, but this is the screen for doing so.

That is, you could, in theory, have one DecSync for your own use and another to share with friends or family.

Having DecSync CC installed allows one to configure his or her device to use DecSync as the default application for contacts, calendars, and tasks. Google will usually be the default provider on Android phones, but some devices may have different defaults (see e.g., /e/ OS devices).

DecSync CC app settings screen.
I use Open Tasks on my phone.

Making DecSync CC the default is done in Android’s settings rather than the app’s, but you can configure the tasks application that will read DecSync from DecSync CC’s settings.

Linux computers

Reading and editing DecSync-backed contacts, calendars, and tasks on a Linux computer is a bit more involved than on the DecSync CC app. I will focus primarily on the most versatile solution, Radicale-DecSync, which allows a client who uses CalDAV/CardDAV to read and edit DecSync information. I personally use Radicale-DecSync with Thunderbird as my client. However, there are a couple of alternative solutions which I will link to, but not discuss in detail.

Solutions I am not reviewing

  • Evolution-DecSync: DecSync plugin for allowing the Evolution email client to use DecSync contacts and calendars. I did test it a couple of years ago and found that it works. However, I opted to use Thunderbird instead of Evolution, so I do not have much to note other than that the configuration instructions worked as promised.
  • DecSync-Akondi: A DecSync solution for KDE’s Akondi. I have not tried it and I note that there have been no commits​​​ in three years (as of the publication of this article), but it may be worth a look for people who use the KDE suite of applications.
  • decsync-vdir: I am not familiar with vdir, but if you are, you can study this DecSync implementation.

Note: Evolution-DecSync and Akondi DecSync are both available in the Arch User Repository.

Radicale DecSync

Radicale is a free and open source CalDAV and CardDAV server. One would ordinarily run Radicale on a centralized server. Radicale stores calendars, to-do lists, and contacts. One would not ordinarily manage any of the above on Radicale. Instead, you use a client that is compatible with CalDAV and CardDAV to connect to the Radicale server. The selection of CalDAV and CardDAV clients is a bit lacking. Thunderbird, a cross-platform free and open source email client, is the most notable client on desktop.

Radicale DecSync is a version of Radicale with DecSync functionality.

Mr. Gunsing provides excellent instructions for how to use and install Radicale DecSync. The Radicale plugin is available from the Python Package Index (via pip). Radicale DecSync is available in the Arch User Repository for people using Arch-based Linux distributions. I use the AUR package on my desktop and laptop (both of which currently run EndeavourOS).

The ordinary use case for Radicale is to run it on a server. However, the main idea behind Radicale DecSync is that it is run locally, wherein it serves as an intermediary between the DecSync directory and a CardDAV/CalDAV client. I will use Thunderbird as my example since that is likely the most common client for the purpose and the one that I personally use.

After installing Radicale DecSync, the user must edit Radicale’s configuration file to point it to the DecSync directory (the process is simple and GitHub offers clear instructions). After configuring the plugin, the user can launch the Radicale server with a simple command, noted on GitHub:

python3 -m radicale --config "~/.config/radicale/config"

The server does not autostart by default. While it can be configured to autostart, I personally start it only when I need it by using an alias for the otherwise unwieldy start-up command.

The server can be accessed at localhost:5232. The developer notes that any username and password should work fine so long as the server is not remotely accessible.

Screenshot of Radicale DecSync running on localhost.
Screenshot of my local Radicale set-up in the Badwolf web browser.

Once Radicale DecSync is configured and running, one can set it up with a CardDAV/CalDAV client. My client of choice is Thunderbird. Set-up is relatively easy – you add your contacts, calendars, and tasks individually (or whichever of the three you are using). Each has a local URL (see localhost:5232) to point Thunderbird to. For configuring the client, you should consult your client’s instructions.

While it is possible to create memos in Radicale, and therefore possible in Radicale DecSync, there is no compatible client that can use DecSync for memos. Thus, as of now, the tool only works for contacts, calendars, and tasks.

(Note: I have only used Radicale DecSync on Linux. While I assume it could run on other systems, I have no experience with trying to do so.)

Reviewing DecSync for Contacts, Calendars, and Tasks

Contacts, Calendars, and Tasks present the best use-case for DecSync. The Android DecSync CC app is very polished and easy to use, and I credit it with providing a good set-up workflow for people using it for the first time. The app is user-friendly and, at a minimum, it makes it easy for people to synchronize contacts, calendars, and tasks between two or more Android (or Android-derived) devices. I have had no issues with DecSync CC’s integration into the phones and tablets I have tested it on.

Setting up DecSync on Linux is less intuitive than on Android and requires a bit more work. Set-up, from installation from source or from a package manager, and editing the relevant configuration file is well-documented, but it is slightly more involved than installing an app from F-Droid and following the graphical set-up flow.

Commenting only on using Thunderbird as a client for Radicale DecSync, the set-up does work well once it is up and running. My main issue is that I do not find that Thunderbird is a very good client for tasks, however synchronization does work well. There are two notes regarding syncing. Firstly, if you try to edit tasks without Radicale running, your address book, calendars, and tasks may be turned to read only mode even after you start the local Radicale server. This is easy to switch, but worth being aware of. Secondly, on one occasion I had an issue where my contacts were out-of-sync, meaning I had two-to-three contacts on my phone that were not on my computer. However, when I made a single edit to a contact on my phone, everything was synchronized properly.

DecSync for RSS and ATOM feeds

See the official DecSync RSS specification.

There are currently three RSS and ATOM clients that work with DecSync.

Android clients:

Both Android clients are available on F-Droid.

Linux client:

(Note: If you are not familiar with feeds, see my general introduction to RSS and ATOM feeds and my essay on using feeds in conjunction with a read-it-later solution for online reading. While you are at it, consider adding The New Leaf Journal to your feed collection.)

How you install FeedReader-DecSync depends on your Linux system. The GitHub repository provides pre-built .deb binaries for FeedReader-DecSync and Libdecsync. I tested installing on Linux Mint and Bodhi Linux using these binaries and found that they worked as expected. I installed it on my main computer, which first ran Manjaro Linux before switching to EndeavourOS, from the Arch User Repository. Those on other systems can build it from source following the instructions on GitHub.

In all three cases, Mr. Gunsing forked and modified a feed reader that was no longer being maintained. The three readers are all clean and modern-looking even though the upstream projects have been abandoned.

I used DecSync as the base of my feed reading system for about one year. On mobile devices, I used Flym-DecSync because I preferred it to spaRSS.

Page for Flym-DecSync in F-Droid.

However, spaRSS-DecSync is solid from my limited use of it, so whether one opts for Flym or Spa is a matter of taste.

Page for spaRSS DecSync in F-Droid.

For its part, Flym has a clean UI and reader and reliably retrieves full text from truncated RSS and ATOM entries. It is easy to add feeds and organize feeds into folders, but there is no tagging or sub-folders. My only quibbles with Flym are that there were a small number of feeds for which it struggled to reliably retrieve individual articles (a problem not unique to Flym, however), and it is too easy to accidentally force Flym to poll feeds by pulling down when it is at the top of the list of new articles. On the whole, Flym, as a feed reader, compares favorably to most of the open source options on Android.

FeedReader was a popular GTK-based feed reader that has been supplanted by NewsFlash (NewsFlash does not have DecSync support). One reason I ultimately moved away from my DecSync set-up for feeds was, in addition to the fact that I prefer reading articles on mobile devices, that I do not much like FeedReader. While I use a GTK-based desktop on my primary computer (XFCE), FeedReader is a bit too big and blocky for my taste. Unlike Flym and spaRSS, it does not retrieve full text from truncated feeds. For full text feeds, it provides a decent reading experience superior to that of many Linux options. Its internal browser is adequate, but I prefer opening links in a regular web browser. FeedReader does have excellent internal search functionality for new and saved articles (perhaps its best feature).

Syncing between devices usually worked, but I had more hiccups with DecSync for RSS and ATOM feeds than for contacts, calendars, and tasks.

The first issue is that FeedReader on Linux can be temperamental to set up. It seems to need to use gnome-keyring in order to retrieve and show feeds. When I configured it to use KeepassXC on an initial set-up without gnome-keyring, it did not work. This issue was reported here.

Secondly, while my read-state (meaning marking articles as having been read) usually synced between devices, it struggled to sync read states with certain feeds, and there were occasions, especially with FeedReader on computer, when something I read was not marked as having been read. This issue was somewhat ameliorated when I pointed my phone, tablet, and computer at my laptop, which always had Syncthing running.

Finally, I encountered some occasional bugs with FeedReader. On initial set-up, it would sometimes miss a folder or feeds for reasons I did not understand. My final issue was when I accidentally moved one folder with feeds into another folder, which caused it to disappear from my list on FeedReader.


DecSync for feeds is an amazing idea, and for the most part it works well, but I would generally only recommend it for those who plan to do most of their reading with one of the mobile clients.

Because most local feed readers rely on databases, they are not amenable to syncing via Syncthing (or in many cases, cloud storage providers since issues arise if the database is updated from multiple locations simultaneously). Thus, syncing feeds, favorites, and read states usually requires a service or central server. The ability to keep feeds entirely local is very neat. If one’s use case was syncing between mobile devices (e.g., between a phone and tablet), DecSync would be just about perfect. But I encountered enough technical issues with FeedReader on my computer that, combined with my not particularly liking FeedReader as a client (perhaps a matter of taste), made it less amenable for that use-case.

If you remove a device or app, that device’s or app’s subdirectory in DecSync’s RSS directory is generally not removed automatically. While this is not a problem, some users (i.e., me) may want to perform some folder house-cleaning after removing a device or app from the DecSync RSS chain.

I would very much like to see DecSync for RSS receive much more development. For example, it would be great if someone built a new feed reader with DecSync integration in mind, allowing it to grow with DecSync. While I think Flym is still a good RSS client, both Feeder and Handy Reading (both available on F-Droid) are superior clients. If one or both, or a currently developed reader of similar quality, added DecSync functionality, that would bring local feed syncing to a broader audience. In the desktop case, I would be interested in seeing DecSync built into a more aesthetically neutral feed reader than FeedReader (e.g., Liferea) or, perhaps better yet, one that also works on Windows. While I do not use Windows, a true cross-platform feed reader would bring DecSync for RSS to a much broader audience.

OsmAND DecSync

Nearly all of the current DecSync implementations are for contacts, calendars, tasks, and feeds. However, there is one niche implementation available for Android in OsmAND DecSync. This application, created by Mr. Gunsing, is available on GitHub. It works with OsmAND, a very good Open Street Maps-based Google Maps alternative for Android. The Readme for the app explains that it “synchronizes the favorites of OsmAnd using DecSync without requiring a server.” I tested it about one year ago and found that it works as advertised. However, I did not use it extensively since I seldom use maps on mobile devices. I could see OsmAND being interesting for some collaborative use-cases. For example, one could set up a special DecSync directory to sync OsmAND favorites with friends and family for use on walking trips, vacations, or the like.


The ethos behind DecSync is in line with the ideas that I articulated in my essay on the digital home. DecSync is a tool to give users full control over their contacts, calendars, tasks, and feeds without relying on third-party providers. It keeps data in house, and this is something to be encouraged.

In addition to my notes on improving DecSync for feeds, I would be interested in seeing projects that consider how DecSync, or any similar tool, could be used for collaborative work. For example, Syncthing can work as a collaboration tool if one is aware of its limitations. While I have not tried it, DecSync already offers some functionality for collaborative calendars and tasks (see my above note on OsmAND). I would be curious whether there are some other uses wherein DecSync could enhance the ability of Syncthing or similar peer-to-peer syncing solutions to facilitate projects and other collaborative work.

I conclude by commending Mr. Gunsing for his great work on DecSync and on developing implementations for it, and note again that I personally use it for contacts, calendars, and tasks (albeit, I am not a big calendar or task user as a general matter). I hope that this important project receives more interest from other talented developers with an interest in local sync solutions and hope to see it folded into new applications. You can contribute to the project on GitHub.

Additional note: DecSync needs a logo or mascot. My services are available (see my amazing newsletter mascots).

(Note: If you have any technical corrections or recommendations to improve this article, feel free to send me an email with the information and how you would like to be credited for the tip if I include it in an update.)