A private calendar and task manager for the web and Android.
Your events stay on your device or on your own CalDAV server. Self-host it in one command.
Live demo · Hosted edition · Self-host · How E2EE works · Sponsor
|
Try it now, nothing to install. The hosted app at
calendar.patryk.pro is the live demo: open it and choose
On this device to try every feature without an account. Don't want to run a server? The hosted edition at calendar.patryk.pro is the same app plus an end-to-end encrypted cloud that keeps your phone, tablet and computer in sync. Nobody but you can read your calendar, not even the service. Calendars on the device and on CalDAV servers are free there too; only the cloud is paid, after 14 free days (compare). Using it supports the development of this free edition. |
|
- Features
- Self-hosted or hosted?
- How end-to-end encryption works in the hosted edition
- Self-hosting with Docker
- Configuration
- Behind a reverse proxy
- Running without Docker
- Connecting to CalDAV servers
- Android app
- Development
- Sponsor
- Contributing
- Security
- License
Calendar
- Day, week, month, year and agenda views, plus a custom view of 2–7 days. On phones all six views are one tap away in a bar at the bottom, and a second tap on the custom view's tab chooses its number of days; the Agenda and custom view tabs can be hidden in Settings → General (a hidden view can still be the default view)
- Drag to create, move and resize events. On a touch screen, tap to open an event and long-press to pick it up
- Create events in place, or open the full editor for time zones, custom repeat rules, reminders, busy/free and more
- Recurring events: edit or delete this event, this and future events or all events
- Invitations: reply Yes / Maybe / No from the event popover
- Birthdays and anniversaries: give a birth date or the day it all started, and every view, search and reminder shows the years ("Anna's birthday (36)", "10th anniversary")
- Hidden events: the eye beside the title keeps an event's name off the screen; views, search and reminders show Hidden event until you open it
- Persistent notifications: an event's or a task's reminder can stay until you dismiss it or mark the task done. Completing, deleting or moving the item takes it down too. In a browser it asks to stay on screen where the browser allows that; on Android it is pinned (below)
- A one-click Join button for Zoom, Teams, Jitsi, Webex and other meeting links
- Public holidays for 19 countries, computed on the device (nothing is downloaded)
- Undo for every change, keyboard shortcuts, search that ignores diacritics
- Subscribe to
.ics/webcal://feeds. Import and export.icsfiles
Tasks
- A tasks drawer grouped into Overdue, Today, Tomorrow, Upcoming, No date and Completed
- Quick add with natural-language dates in English and Polish (
Call Anna tomorrow,Gym fri) - Due dates, priorities, progress, notes, recurrence, reminders and subtasks
Storage
- On this device: no account and no server. Works offline
- CalDAV: Nextcloud, Radicale, Baïkal, Fastmail, iCloud, mailbox.org, Posteo, Synology and more. Incremental sync (RFC 6578), conflict-safe writes, creating calendars and task lists
- Use several CalDAV accounts side by side. Move my data… copies or moves calendars between places and checks every item before anything is deleted
- Backup (Settings → Backup): one file with every calendar and task list kept on the device, all their events and tasks, your subscribed and holiday calendars and your settings. Restore it on the same device or another one, also from the welcome screen; nothing on the device is deleted. A notice above the calendar asks for a new backup every 30 days (or as often as you choose), and the app says once which things can delete calendars kept on a device
Look and languages
- Five themes (Daylight, Linen, Graphite, Night, High contrast), your own accent colour, four event styles, 12 bundled fonts, two densities and five text sizes
- Interface in English, Polish, German, Spanish, French, Italian, Portuguese (Brazil), Ukrainian, Czech and Dutch
Android
- Native CalDAV client (no proxy, no CORS issues)
- Reminders fire even when the app is closed: exact alarms, rescheduled after a reboot, and CalDAV calendars refreshed hourly in the background
- Persistent notifications stay pinned: a swipe brings one back at once, without a sound, and so do a restart and an app update. Dismiss and Snooze 10 min end it, and a task's Done opens the app and marks the task done
- The round + button adds an event, or, as Settings → General → Round + button chooses, a task or a small menu of the two
- Home screen widgets: Agenda, Today, Month and Tasks, each with its own calendars, look (the system's, light or dark) and background. A tap opens the day, the event or the task, adds a new one, or marks a task done
- No ads, no trackers, no analytics and no consent pop-ups
Both are the same calendar app, Calendar CE. The self-hosted edition is this repository: you run the web app yourself and build the Android app from it. The hosted edition is ready on the web and on Google Play. It adds an end-to-end encrypted cloud that keeps your devices in sync.
What is free: in both editions, calendars and tasks on the device and on CalDAV servers, with no account and no time limit. What is paid: only the hosted edition's cloud, after a 14-day free trial.
| Self-hosted (this repo) | Hosted (calendar.patryk.pro) | |
|---|---|---|
| Calendars and tasks on the device, no account | ✓ free | ✓ free |
| CalDAV accounts (Nextcloud, Radicale, iCloud, …) | ✓ free | ✓ free |
| End-to-end encrypted cloud that syncs your devices | – | ✓ 14 days free, then a monthly or yearly plan |
| Settings that follow you to every device | – | ✓ with the cloud |
| Encrypted profile picture, Recovery Kit | – | ✓ with the cloud |
| Web app | you host it: Docker image or Node | ready at calendar.patryk.pro |
| Android app | you build it from this repo | Google Play |
| Account | none | only for the cloud: an e-mail address and a password |
| Ads | none | none on the web. The Google Play app shows one small banner when it is used without a cloud plan; an optional subscription in the app removes it |
| Server to run and update | yours | none |
| Price | free and open source (AGPL-3.0) | free on the device and with CalDAV; the cloud after its 14-day trial: a monthly or yearly plan |
How the cloud plan works
- The trial starts with a new cloud account and lasts 14 days. No payment details are needed for it, and it is given once per e-mail address.
- Plans are monthly or yearly, bought in the Android app from Google Play, which shows the price for your country. A plan covers every device signed in to the account, the web app included.
- When the trial or a plan ends, the cloud becomes read-only on every device: your calendars stay visible and can be exported, or moved to the device or a CalDAV server. Their data is deleted from the server 120 days later, after a warning at day 90. A plan bought in the meantime brings writing back at once.
- Calendars on the device and on CalDAV servers are not affected by any of this: they keep working, free, with or without a plan.
The self-hosted edition never sends your calendar to anyone but the CalDAV server you choose. The hosted edition adds a cloud that syncs your devices, and it's built so that the cloud can store your calendar without being able to read it.
flowchart LR
subgraph device["Your device"]
P["Password<br>(never leaves the device)"]
S["Secret Key<br>(made on the device, never sent)"]
K["Your data key"]
D["Events, tasks, calendars, settings"]
P --> KDF["Argon2id"]
S --> KDF
KDF -->|unlocks| K
D -->|"AES-256-GCM"| E["Ciphertext"]
K -.-> E
end
E -->|"HTTPS"| C[("Cloud<br>stores ciphertext only")]
C -->|"sync"| O["Your other devices<br>decrypt locally"]
- Keys are made on your device. When you create an account, your device generates a random Secret Key. Together with your password it goes through Argon2id (deliberately slow, 64 MiB of memory) to derive the key that unlocks your data and a separate secret for signing in. Neither the password nor the Secret Key is ever sent.
- Everything is sealed before it leaves. Calendar names, colours, every event and task (titles, times, repeat rules, places, notes, guests, reminders) and all your settings are encrypted with AES-256-GCM. Each value is bound to where it belongs, so the server can't change an item, move it or slip it into another account without your devices noticing.
- The cloud only relays ciphertext. It stores what it gets and passes it between your devices. Someone who breaks into its database sees sealed blobs, and because the Secret Key never reached the server, they can't even try to guess your password against them.
- You keep the way back. After sign-up you get a Recovery Kit (your Secret Key and a Recovery Key) to reset a forgotten password. Without the kit and the password, the data can't be opened by anyone, including the service.
| Encrypted on your device | What the service can still see |
|---|---|
| Calendar names, colours, descriptions | Your e-mail address (and name, if you give one) |
| Every event and task, in full | How many calendars and items you have, and their approximate sizes |
| All settings, holiday calendars, subscriptions | When items were created, changed or deleted |
| Your profile picture | Your signed-in devices |
Read the code. The client-side encryption is published in src/lib/crypto/ with fixed test vectors,
and docs/ENCRYPTION.md specifies it byte for byte. The self-hosted edition doesn't use it; it's
there so anyone can verify how the hosted cloud protects data.
The hosted web app is loaded from the server at each start, so for the strongest guarantee use the Android app, whose code ships inside the signed APK.
Every release is published as a ready-made image, ghcr.io/sysoppl/calendar-ce, for linux/amd64 and
linux/arm64 (a Raspberry Pi 4/5 or an ARM server works too). There's nothing to build: you need Docker with the
Compose plugin and the docker-compose.yml of this repository.
| Image tag | What it is |
|---|---|
latest |
The newest release: the default in docker-compose.yml and in the examples below |
X.Y.Z |
One exact release (see the releases page): you decide when to update |
X.Y |
The newest release of the X.Y line |
X |
The newest release of version X |
The container holds no data: calendars live in the browser (On this device) or on your CalDAV server. Replacing or removing the container loses nothing, and there's no volume to back up.
mkdir calendar && cd calendar
curl -fsSLO https://raw.githubusercontent.com/sysoppl/Calendar-CE/main/docker-compose.yml
docker compose up -dOpen http://localhost:8787. On the welcome screen choose On this device or Connect a server (CalDAV).
The container serves the web app and a small DAV proxy (/dav-proxy). Browsers can't talk to most CalDAV servers
directly (no CORS headers), so the web app relays CalDAV requests through it. The proxy stores nothing and is
locked down by default: it reaches no server until you allow one. Name the CalDAV hosts your users need in
docker-compose.yml, then apply the change with docker compose up -d:
environment:
CALENDAR_PROXY_ALLOW: "cloud.example.com,caldav.fastmail.com"No CalDAV server at hand? The compose file includes a Radicale demo. Set
CALENDAR_PROXY_ALLOW: "radicale", then:
docker compose --profile radicale up -dAdd an account with server http://radicale:5232/ and any user name and password (authentication is off in the demo).
You need a Linux server with Docker, a domain name (here calendar.example.com) whose DNS record points at it, and
ports 80 and 443 open. The app listens on 127.0.0.1:8787 only, and a reverse proxy on the same server
(Caddy or nginx) handles HTTPS.
-
Get the compose file:
sudo mkdir -p /opt/calendar && cd /opt/calendar sudo curl -fsSLO https://raw.githubusercontent.com/sysoppl/Calendar-CE/main/docker-compose.yml
-
Set it up. Edit
/opt/calendar/docker-compose.yml: inenvironment:set your address, the reverse proxy and the CalDAV servers your users may reach. The image islatest; to update on your own schedule, put an exact release (X.Y.Z) in its place:image: ghcr.io/sysoppl/calendar-ce:latest ... environment: VITE_APP_URL: "https://calendar.example.com" CALENDAR_TRUST_PROXY: "1" CALENDAR_PROXY_ALLOW: "cloud.example.com,caldav.fastmail.com" # Optional, shown in the app: VITE_PRIVACY_URL, VITE_TERMS_URL, VITE_CONTACT_URL
The
build:section only matters when you build the image yourself; Compose ignores it otherwise. -
Start it, check that the container reports
healthy, and read what the server says about its settings when it starts (dav-proxy:lines):sudo docker compose up -d sudo docker compose ps sudo docker compose logs calendar curl -I http://127.0.0.1:8787/
-
Put HTTPS in front of it. With Caddy, which gets the certificate by itself:
sudo curl -fsSL https://raw.githubusercontent.com/sysoppl/Calendar-CE/main/deploy/Caddyfile -o /etc/caddy/Caddyfile sudo sed -i 's/calendar.example.com/your.domain/' /etc/caddy/Caddyfile sudo mkdir -p /var/log/caddy && sudo chown caddy:caddy /var/log/caddy sudo systemctl reload caddy
With nginx, use
deploy/nginx.confand a certificate from certbot instead. See Behind a reverse proxy for what both examples take care of. -
Open
https://calendar.example.com. Users who choose On this device keep their calendar in their own browser; those who connect a CalDAV server reach it through the proxy.
cd /opt/calendar
# with a pinned release: change the image tag in docker-compose.yml first
sudo docker compose pull
sudo docker compose up -d
sudo docker image prune -f # removes the previous imageReleases are published on the releases page, with notes of what changed
since the one before and the image to pull. A version is released only after the full test run has passed for its
tag. Every image carries its version and the commit it was built from (org.opencontainers.image.version and
.revision labels), plus an SBOM and build provenance.
The same container with docker run, locked down like the compose file:
docker run -d --name calendar --restart unless-stopped \
-p 127.0.0.1:8787:8787 --read-only --cap-drop ALL --security-opt no-new-privileges:true \
--memory 512m \
-e VITE_APP_URL="https://calendar.example.com" \
-e CALENDAR_TRUST_PROXY="1" \
-e CALENDAR_PROXY_ALLOW="cloud.example.com" \
ghcr.io/sysoppl/calendar-ce:latestUpdate it with docker pull ghcr.io/sysoppl/calendar-ce:latest, then docker rm -f calendar and the same docker run.
With an exact release instead of latest, pull and run the new tag.
From a clone of this repository, for example to run a modified version:
git clone https://github.com/sysoppl/Calendar-CE.git
cd Calendar-CE
docker compose up -d --buildThe image is tagged like the published one (ghcr.io/sysoppl/calendar-ce:latest) on your machine only. If you publish
a modified version, give it your own image name and point the app's Source code link at your fork (AGPL-3.0).
Every setting is an environment variable: environment: in docker-compose.yml, -e for docker run, or
/etc/calendar.env for the systemd unit. A change needs only a restart (docker compose up -d), never a rebuild.
The app:
| Variable | Default | What it does |
|---|---|---|
VITE_APP_URL |
http://localhost:8787 |
The public address of your instance. The DAV proxy only answers requests for its host name |
VITE_PRIVACY_URL |
(empty) | Link to your privacy policy, shown in the app. Empty means it isn't shown |
VITE_TERMS_URL |
(empty) | Link to your terms of service |
VITE_CONTACT_URL |
(empty) | A contact page or a mailto: address |
npm run build reads the same variables, so a build of your own (and the Android app, which has no server) can carry
them too; the server's values take precedence.
The server and its DAV proxy:
| Variable | Default | What it does |
|---|---|---|
CALENDAR_PROXY_ALLOW |
(empty) | CalDAV hosts the proxy may reach, comma separated, *.example.com allowed. Empty means none |
CALENDAR_PROXY_PRIVATE_HOSTS |
(empty) | Dotted names of your own servers on a private network (e.g. dav.home.example) |
CALENDAR_PROXY_ALLOW_PRIVATE |
false |
Let the proxy reach loopback/LAN addresses for every host. Only on a network you trust |
CALENDAR_PROXY_OPEN |
false |
Let the proxy reach any public host while the lists are empty. Only for a server you alone use |
CALENDAR_PROXY_ALLOW_HTTP |
false |
Allow plain http:// with a password to public addresses |
CALENDAR_PROXY_DISABLED |
false |
Turn the proxy off. CalDAV in the browser then only works with servers that send CORS headers |
CALENDAR_PUBLIC_HOSTS |
(empty) | Extra host names this server is reached by, besides the host of VITE_APP_URL |
CALENDAR_TRUST_PROXY |
0 |
Number of reverse proxies in front of the server (usually 1). Needed for per-client rate limits |
CALENDAR_PROXY_RATE / _BURST / _CLIENT_CONCURRENCY / _CONCURRENCY |
600 / 300 / 6 / 32 |
Request budget of the proxy per client address |
CALENDAR_PROXY_AUTH_FAILURES |
20 |
Wrong-password answers one client may get in 10 minutes before it's slowed down |
CALENDAR_PROXY_LOG |
true |
One log line per proxied request (client, method, host, status; never paths or credentials) |
CALENDAR_HSTS |
2 years | Strict-Transport-Security value; off removes it |
PORT / HOST |
8787 / 0.0.0.0 |
Where the server listens (use HOST=127.0.0.1 behind a reverse proxy on the same machine) |
deploy/calendar.env.example explains every server setting in more detail.
Ready-made examples are in deploy/. Both forward to 127.0.0.1:8787, where the container (or the systemd
service) listens:
Caddyfile: automatic HTTPSnginx.conf: with a Let's Encrypt certificate
Replace calendar.example.com with your own domain, and set VITE_APP_URL=https://your.domain and
CALENDAR_TRUST_PROXY=1 for the app. Both examples allow the DAV proxy's request size (10 MiB) and time (90 s), keep
CalDAV addresses and credentials out of their access logs, and pass the client address on. The server sends its own
security headers (CSP, HSTS and others), so don't add any in the proxy.
You need Node.js 24.
npm ci
VITE_APP_URL=https://calendar.example.com npm run build
VITE_APP_URL=https://calendar.example.com CALENDAR_PROXY_ALLOW=dav.example.com npm startFor a permanent install there's a hardened systemd unit in deploy/calendar.service
(it runs from /opt/calendar with the settings in /etc/calendar.env).
| Provider | Server URL | Notes |
|---|---|---|
| Radicale | http://host:5232/ |
|
| Nextcloud | https://host/remote.php/dav |
Use an app password |
| Baïkal | https://host/dav.php |
|
| Fastmail | https://caldav.fastmail.com/ |
App password required |
| iCloud | https://caldav.icloud.com/ |
App-specific password |
| mailbox.org | https://dav.mailbox.org/ |
|
| Posteo | https://posteo.de:8443/ |
|
| Synology Calendar | https://nas:5001/caldav/ |
CalDAV endpoints that only accept OAuth aren't supported. In the browser, remember to add the server's host to
CALENDAR_PROXY_ALLOW.
The Android app is the same code in a Capacitor shell. Its application id is
pro.patryk.calendar.community, so it never clashes with the store app. You need JDK 21 and the Android SDK
(Android Studio brings both).
npm ci
npm run android:sync # builds the web bundle and copies it into android/
cd android
./gradlew testDebugUnitTest # unit tests
./gradlew assembleDebug # app/build/outputs/apk/debug/app-debug.apkA signed release build (./gradlew assembleRelease) reads its keystore from the environment (ANDROID_KEYSTORE_FILE,
ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_ALIAS, ANDROID_KEY_PASSWORD) or from a git-ignored
android/keystore.properties (storeFile, storePassword, keyAlias, keyPassword). Without one, the release APK
is left unsigned.
Prefer a ready-made app? Calendar CE on Google Play.
npm ci
npm run dev # http://localhost:5173, with the DAV proxy built in
npm run typecheck
npm test # Vitest
npm run build # production bundle in dist/In development the proxy may reach a CalDAV server on your own machine (e.g. Radicale on 127.0.0.1:5232).
window.__calendarSeed() in the browser console of the dev server fills the calendar with sample data.
| Path | What's inside |
|---|---|
src/ |
The React app (TypeScript, Zustand, Tailwind CSS) |
src/lib/dav/ |
The CalDAV client |
src/lib/ical/ |
iCalendar parsing, recurrence and time zones |
src/lib/crypto/ |
The hosted edition's end-to-end encryption, published for review |
src/i18n/ |
The 10 interface languages |
server/ |
The zero-dependency Node server and the DAV proxy |
android/ |
The Android shell, native CalDAV client and reminders |
deploy/ |
Reverse proxy and systemd examples |
scripts/ |
Build helpers, screenshots, end-to-end checks |
Calendar CE is free and open source, with no ads and no trackers. If it is useful to you, you can support its development on GitHub Sponsors. Sponsorships pay for the time that goes into fixes, new features and translations.
Using the hosted edition supports the project too.
Contributions are welcome: bug reports, translations, fixes and features that fit a local-first calendar.
- Open an issue first for anything bigger than a small fix, so we can agree on the approach.
- Fork the repo and create a branch from
main. - Keep changes focused, add tests for new behaviour, and make sure
npm run typecheck,npm testandnpm run buildpass. - New interface text goes into
src/i18n/en.tsand every other language (the tests check that all 10 have the same keys). - New dependencies must have a licence compatible with the AGPL-3.0; run
npm run licensesto update the third-party notices. - Open a pull request describing what changed and why.
Before your first pull request is merged, the CLA Assistant bot asks you to sign the Contributor License Agreement once. You keep the copyright in your work; the agreement lets the maintainer also use it in other editions of Calendar CE, such as the hosted one, and keeps everything merged here open source.
Please don't report security issues in public issues. See SECURITY.md.
Copyright © 2026 patryk.pro.
Calendar CE is free software: you can redistribute it and/or modify it under the terms of the
GNU Affero General Public License, version 3 only (AGPL-3.0-only). It comes without any warranty. If you
run a modified version for other people over a network, you must offer them its source code (the app's
Settings → About → Source code link points at the release it was built from; point it at your fork). Third-party
components keep their own licences, listed in public/THIRD-PARTY-NOTICES.txt.
The Docker image contains this app (its licence is /app/LICENSE, the third-party notices are
/app/dist/THIRD-PARTY-NOTICES.txt) on top of the official node:24-alpine image,
which brings Node.js, npm and Alpine Linux packages, each under its own licence. Their sources:
Node.js (the version node --version prints), the
image definition and Alpine's aports
(the branch matching /etc/alpine-release). Every published image lists its packages and their licences in an SBOM:
docker buildx imagetools inspect ghcr.io/sysoppl/calendar-ce:latest --format '{{ json .SBOM }}'.
Names. The AGPL-3.0 grants no rights to the names patryk.pro and Calendar CE or to the Calendar CE icon as marks: please give a build you publish a name and icon of your own. Other product names belong to their owners and are only used to name the services Calendar CE works with. Google Play and the Google Play logo are trademarks of Google LLC.
Made by patryk.pro · Hosted edition: calendar.patryk.pro

















