# nextcloud-tasks: a task manager that syncs over CalDAV

> The Tasks app for Nextcloud is a JavaScript and PHP app that stores your to-do items in Nextcloud and exposes them over CalDAV, so Apple Reminders, Thunderbird, DAVx5, GNOME Todo and a dozen other clients can read and write the same list. It suits a Nextcloud user who wants their tasks to follow them between devices without moving to a hosted service, and the part that trips people up is that the whole conflict handling depends on the ETag HTTP header surviving the trip.

**nextcloud/tasks** — :white_check_mark: Tasks app for Nextcloud

- Repository: https://github.com/nextcloud/tasks
- Website: https://apps.nextcloud.com/apps/tasks
- Stars: 706 · Forks: 123
- Language: JavaScript
- License: AGPL-3.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/nextcloud-tasks

## One task list, many clients, one storage backend

The Tasks app for Nextcloud is described as a tasks app that lets you easily sync tasks from various devices with your Nextcloud and edit them online. The storage is Nextcloud itself, and the interoperability comes from CalDAV.

That architecture is the whole point. Your tasks are not in a proprietary format held by a vendor, they are stored in your own Nextcloud, and the app serves them over CalDAV so that any client that speaks the protocol can work with them. The README lists the clients that sync with Nextcloud Tasks, and the range is the argument for the approach: Apple Reminders on iOS and MacOS, 2Do on Android, iOS and MacOS, Davx5 on Android, OpenTasks on Android, Outlook CalDav Synchronizer on Windows, Astrid on Android, Qownnotes as a read-only cross platform desktop app, Thunderbird Lightning as a cross platform desktop app, BusyCal on MacOS, aCalendar+ on Android via Davx5, GNOME Todo on Linux via GNOME Online Accounts, Kalendar on Linux, vdirsyncer on Linux and BSD, planify on Linux, jtx Board on Android, and NowThis on iOS and macOS.

The list is long enough that it changes the argument. A hosted task service gives you one official app and whatever third party clients the vendor chooses to support. Nextcloud Tasks gives you your own storage and a protocol, and the set of clients is assembled by whoever cares to implement it.

The feature set inside the app itself is deliberately small. You can add and delete tasks, edit their title, description, start and due dates, set their priority and status, and there is support for subtasks. There are smart collections showing you your important, current and upcoming tasks. And you can simply drag and drop tasks to other calendars or make them subtasks.

That drag and drop line is worth pausing on, because it shows the data model is calendar-like rather than list-like. Tasks live in calendars, which is what makes the CalDAV interoperability natural rather than bolted on, and which is also why subtasks and moving between calendars are the same kind of operation.

## The ETag dependency, and the browser extensions that break it

There is a section in the README titled ETag (or: problem with non-existing conflicts), and it is the most important operational detail in the project.

The app uses the ETag HTTP header to work properly, mostly for detecting conflicts. If ETags are modified or removed, the app will report non-existing conflicts. That is the failure mode in one sentence: two clients edit the same task, the server cannot tell whether the version changed, so the app invents a conflict that is not there.

The cause is usually on the client side. Some anti-tracking client side extensions are known to remove or replace the ETag header to avoid tracking via cache, and CleanURLs is named as a known problem with a link to the issue. The fix is to add an exception for NC Tasks in the extension. The project also links the issue tracker, and the tone of it is not the tone of a bug report, it is the tone of an explanation of why the extension behaves this way.

The same thing can happen on the server side. ETag may be modified by a server-side configuration, and if you manage your server you will need to change its configuration, with a second issue link for that case. So the troubleshooting path splits cleanly: if the problem appears in one browser, look at the extensions; if it appears for every client, look at the reverse proxy or the web server configuration.

This is a real cost of the CalDAV approach, and it is worth understanding before you adopt it rather than after. The protocol uses ETag as its concurrency control primitive, and a surprising number of things in the request path are entitled to rewrite or drop that header. A task list is exactly the kind of data where you sync from several clients, so several clients means several extension sets, and the ETag dependency means one badly configured extension can make the whole list look broken.

The app also supports subtasks and calendar moves, and those operations are where a wrong conflict decision does the most damage, since a conflict on a move is a task that appears in two places or none.

## A Vite and Vue front end on top of a Nextcloud app shell

The repository layout shows a modern Nextcloud app rather than the older style of bundled jQuery, and the package manifest is where you can see the stack.

The front end is Vue 3, with `vue` at 3.5.44 and `@nextcloud/vue` at 9.13.1 providing the component set, plus `vue-router` and `vuex` for routing and state. The build is Vite, with `vite build --mode production` for the build and a development mode and a watch mode for local work, and there is a `vite.config.mjs` at the repository root. The package is marked `"type": "module"`, so the whole front end is ES modules.

The Nextcloud libraries are the specific set you would expect. `@nextcloud/axios` for HTTP, `@nextcloud/cdav-library` at 2.8.0 for the CalDAV side, `@nextcloud/calendar-js` pinned at 8.1.7 for calendar parsing, `@nextcloud/router` for URL generation, `@nextcloud/initial-state` for the server-provided bootstrap state, `@nextcloud/l10n` for translations, `@nextcloud/dialogs`, `@nextcloud/logger` and `@nextcloud/event-bus`.

The CalDAV part is the substantive dependency. `ical.js` is present for iCalendar parsing and `dompurify` for sanitising the HTML that task descriptions can contain, alongside `markdown-it` with a stack of plugins: emoji, link attributes and task lists, which is what turns a markdown description into a checklist. `sortablejs-vue3` and `debounce` support the drag and drop behaviour, `color-convert` handles the priority colours, and `@vueuse/components` provides the composition utilities.

The linting setup is complete and conventional. ESLint covers the JavaScript and Vue files under `src` and `tests`, with a `.eslintrc.cjs`, a `babel.config.cjs` and a `.prettierrc.js` for formatting, and Stylelint over the SCSS in `css` with its own config. The tests are Vitest, run with `vitest run`.

The PHP side is the usual Nextcloud app structure: `appinfo/` for the app metadata, `lib/` for the server code, `templates/` for the server-rendered views, `l10n/` for translations, `src/` for the front end sources, `css/` for the styles, `tests/`, and both `phpunit.xml` and `phpunit.integration.xml` so unit and integration tests are separated.

## Installing the app and building it from source

Installing the released app is a few clicks. In your Nextcloud, navigate to Apps, choose the category Organization, find the Tasks app and enable it, then open the Tasks app from the app menu. The app is listed in the Nextcloud app store at apps.nextcloud.com/apps/tasks.

Building it yourself is the developer path, and the README is explicit about the requirements. Clone the repository into your apps directory, with a Nextcloud server installation needed, and additionally nodejs and npm are needed for installing the JavaScript dependencies.

Once node and npm are installed, PHP and JavaScript dependencies can be installed by running:

```bash
$ make
```

And the instruction that follows is worth passing on to anyone else on the team: execute this command with your ordinary user account and neither root nor sudo. The Makefile in the repository explains why. It is a generic Makefile for building and packaging a Nextcloud app which uses npm and Composer, and it locates the `occ` binary relative to the app directory at `$(CURDIR)/../../occ`, which means the app has to sit inside a real Nextcloud server checkout for the packaging and signing targets to work.

The signing part is the most Nextcloud-specific thing in the Makefile. It expects the private key at `$(HOME)/.nextcloud/$(app_name).key` and the certificate at `$(HOME)/.nextcloud/$(app_name).crt`, and it signs with `php -f $(occ) integrity:sign-app`. If either file is missing, or occ cannot be found, the Makefile skips signing rather than failing, and says so. The `appstore_build_directory` and `appstore_package_name` variables are for producing the artifact layout the app store expects.

The Makefile also documents its own dependencies, which is a nice touch: make, which, curl used if phpunit and composer are not installed to fetch them from the web, and tar for building the archive.

## What the app does not do, and where a hosted task service differs

The comparison worth making is with a hosted task service, because the two overlap in the user's eyes but differ in what they promise.

A hosted service such as the one behind Apple Reminders or Todoist gives you a shared account, a native app on every platform, and a support commitment. It also means your task list lives on somebody else's servers, and in the Apple case it lives in a platform account that is tied to an ecosystem. Nextcloud Tasks is the opposite: the data is in storage you control, and the set of clients is assembled from whatever implements CalDAV.

The cost of that choice is the client experience. The apps in the sync list are good enough, but they are not one product, and the interactions differ. A subtask added in the Nextcloud web interface and a subtask added in Thunderbird should agree, but the UI for the same task is not the same, and the Nextcloud app's own feature set, subtasks and smart collections, is richer than most of the third party clients expose. In practice people end up with the Nextcloud app on the web and one native client on the phone.

The other difference is the conflict story. A hosted service controls both ends of the sync and can implement whatever merge semantics it likes. The Tasks app implements the CalDAV model, which means conflict handling is delegated to ETags and to whatever the server does with them. That is a simpler protocol and a better interoperability story, and it is also the source of the problem described above.

It is also worth being clear about the scope. The feature list is short, and there is no attachment handling, no natural language date parsing, no reminders push from the server, and no collaboration on a shared list. The app is a task list with subtasks, priorities, dates and smart collections, and it is a good one of that, with the interoperability as the reason to choose it.

The project is AGPL-3.0 licensed, the last push was on 2026-10-20, and the latest listed releases are v0.18.1 from 2026-06-29, v0.18.0 from 2026-06-22 and v0.17.1 from 2025-11-09.

## Conclusion

Adopt the Tasks app if you already run Nextcloud and want your task list to live with your other data while remaining editable from the phone, desktop and calendar clients you already use. Do not adopt it if your clients strip the ETag header, because the app's conflict detection depends on it and the documentation says it will report conflicts that do not exist, and check first whether any browser extension or reverse proxy in your setup removes ETag, since the fix is a per-client exception rather than a change to the app.

## FAQ

### What is the Nextcloud Tasks app?

It is a tasks app for Nextcloud that stores your to-do items in Nextcloud and lets you sync tasks from various devices and edit them online. It supports subtasks, smart collections of important, current and upcoming tasks, and drag and drop between calendars.

### Which apps can sync with Nextcloud Tasks?

The list is long because the app serves its data over CalDAV. It includes Apple Reminders, 2Do, Davx5, OpenTasks, Outlook CalDav Synchronizer, Astrid, Qownnotes, Thunderbird Lightning, BusyCal, aCalendar+, GNOME Todo, Kalendar, vdirsyncer, planify, jtx Board and NowThis.

### Why do I get conflicts that do not exist in the Nextcloud Tasks app?

Because the app uses the ETag HTTP header to detect conflicts, and if ETags are modified or removed it will report non-existing conflicts. Anti-tracking browser extensions such as CleanURLs are known to remove or replace the header, in which case you need to add an exception for NC Tasks, and a server-side configuration that alters ETag has the same effect.

### How do I install the Tasks app on Nextcloud?

Navigate to Apps in your Nextcloud, choose the Organization category, find the Tasks app and enable it, then open it from the app menu. The app is also listed in the Nextcloud app store.

### How do I build the Tasks app from source?

Clone the repository into the apps directory of a Nextcloud server installation, install nodejs and npm for the JavaScript dependencies, then run make to install the PHP and JavaScript dependencies. The Makefile expects the app to sit inside a Nextcloud checkout, since it locates occ relative to the app directory, and it asks you to run the command as your ordinary user rather than root.

### Is the Nextcloud Tasks app still being maintained?

The repository is not archived and the last push was on 2026-10-20. Recent releases include v0.18.1 from 2026-06-29, v0.18.0 from 2026-06-22 and v0.17.1 from 2025-11-09, and the app is AGPL-3.0 licensed.

## Sources

- [License: AGPL-3.0](https://github.com/nextcloud/tasks/blob/main/LICENSE)
- [nextcloud/tasks on GitHub](https://github.com/nextcloud/tasks)
- [Project website](https://apps.nextcloud.com/apps/tasks)
- [README](https://github.com/nextcloud/tasks/blob/main/README.md)
- [Releases](https://github.com/nextcloud/tasks/releases)

---

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