Donetick

Donetick is a lightweight, open‑source task management platform that emphasizes developer friendliness through a clean RESTful API, extensible plugin architecture, and container‑ready deployment. At its core, the application exposes a set of JSON endpoints that allow CRUD operations on tasks, subtasks, labels, and the novel “Things” entity. The server is written in Go, leveraging the gin web framework for routing and middleware, while data persistence is handled by a PostgreSQL database accessed through gorm. This stack provides strong type safety, high performance, and minimal runtime overhead—ideal for micro‑service or monolithic setups.

• Language & Framework: Go 1.22+, gin-gonic/gin for HTTP routing, gorm.io/gorm for ORM abstraction. The codebase follows a layered architecture (controllers → services → repositories) with dependency injection via the wire package.
• Database: PostgreSQL 15+ is used for relational storage of tasks, users, groups, and metadata. The schema supports many‑to‑many relationships (e.g., task labels) and JSONB columns for flexible “Thing” values.
• Storage: File attachments are stored either locally (via the os package) or on S3‑compatible object stores, configured through environment variables.
• Background Jobs: A lightweight scheduler (robfig/cron) runs recurring tasks and adaptive scheduling logic. Webhooks are triggered via HTTP callbacks defined in the API.
• Containerization: A Dockerfile is provided; images are pushed to Docker Hub (donetick/donetick). The container exposes a single port (8080) and expects PostgreSQL to be reachable via PGHOST.

• Natural Language Parsing: The /tasks endpoint accepts a description field; the server uses the open‑source nlp library to extract dates, recurrence patterns, and due times.
• Adaptive Scheduling: Tasks can be scheduled based on the last completion date or the original due date. The adaptive engine learns from completion timestamps to suggest next due dates.
• Subtask Hierarchy: Recursive subtask trees are stored as parent‑child relationships; on completion of a recurring task, all subtasks reset automatically.
• Things API: GET /things, POST /things, and PATCH /things/:id allow developers to treat arbitrary data as observable triggers. Tasks can be linked to a “Thing” change event via webhook or polling.
• NFC Integration: A minimal REST endpoint (/nfc/:tag) can be polled by an NFC reader; scanning a tag triggers a task completion event.

Donetick is designed for self‑hosting in both cloud and on‑prem environments. The Docker image is stateless, making horizontal scaling straightforward; a load balancer can route traffic to multiple replicas. For persistence, the PostgreSQL instance should be configured with replication or a managed service for high availability. The scheduler can run as an init container or as part of the main image, ensuring that recurring jobs persist across restarts. Kubernetes manifests are available in the deploy/k8s directory, featuring a Deployment, Service, and ConfigMap for environment variables.

The API follows OpenAPI 3.0 specifications, enabling auto‑generated SDKs in Go, Python, TypeScript, and more. Webhooks can be configured per task or group; they send JSON payloads to arbitrary URLs on state changes. A plugin system is in place: developers can drop a Go plugin (*.so) into the /plugins directory, and the server will load it at runtime to extend routing or business logic. Additionally, the UI is built with SvelteKit and can be swapped for a custom front‑end by consuming the same API.

Configuration is entirely environment‑driven, with sensible defaults and a comprehensive .env.example. Documentation resides in the docs/ folder and is hosted via GitHub Pages. The community actively maintains a Discord server for real‑time support, and the issue tracker is open to feature requests. The project’s MIT license removes licensing friction for commercial use.

• Team Task Coordination: Small teams can deploy Donetick on a private server to manage shared chores, with automatic assignee rotation and point tracking for gamification.
• IoT Integration: By exposing NFC or webhook endpoints, developers can tie physical actions (e.g., scanning a tag to mark trash day) into the task flow.
• Custom Workflows: The “Things” feature allows building monitoring dashboards that trigger tasks when a sensor reports a threshold breach, useful in DevOps or smart‑home scenarios.
• Self‑Hosted Analytics: Companies that require GDPR‑compliant data residency can host Donetick locally and use its built‑in analytics to track productivity metrics without sending data to third parties.

Donetick offers a highly extensible, low‑overhead alternative to heavyweight task managers. Its Go implementation delivers performance comparable to native binaries, while the open‑source license and Docker support reduce operational friction. The built‑in natural language parsing, adaptive scheduling, and “Things” concept give developers a richer domain model than many competitors. Combined with a robust API, webhook system, and plugin hooks, Donetick empowers developers to embed task management into bespoke workflows