Joplin

Joplin is a cross‑platform, open‑source note‑taking engine that prioritises data locality and end‑to‑end security. From a developer’s perspective, it is essentially a client–server architecture that can run entirely offline or sync via any of several cloud back‑ends. The core engine is written in TypeScript and compiled to JavaScript/Node.js for the desktop, while the mobile clients use React Native (Android/iOS) and a lightweight Electron wrapper for Windows, macOS, and Linux. The underlying storage is an encrypted SQLite database that lives locally on each device; the sync layer is pluggable and can target Nextcloud, Dropbox, OneDrive, or a custom HTTP/REST endpoint.

• Frontend: Electron + React for desktop; React Native for mobile. The UI renders Markdown via marked and supports a Rich Text editor built on top of quill.
• Backend: Node.js server bundled with Electron; the same codebase powers the CLI (joplin.exe/joplin) used on Linux/macOS.
• Storage: Encrypted SQLite (AES‑256) with optional per‑note encryption. The schema is deliberately flat to keep sync simple and fast.
• Sync: A modular sync engine that implements the Joplin Sync Protocol over HTTP or WebDAV. The protocol is RESTful and versioned, enabling future extensions without breaking compatibility.
• Testing: Jest + Cypress for unit and end‑to‑end tests; CI runs on GitHub Actions with Docker containers.

• Full‑text search powered by SQLite FTS5, accessible via the UI and a public API (/search).
• Plugin system: Plugins are simple Node modules that expose a JSON manifest and optional TypeScript/JavaScript files. They can hook into events (note added, edited, deleted) and expose UI components via the Extension API.
• Web Clipper: A Firefox/Chrome extension that injects a lightweight UI and communicates with the local Joplin client over http://localhost:41184.
• Command‑line interface: CRUD operations, note export/import (Evernote ENEX, Markdown), and sync control are all available through the joplin CLI.
• E2EE: The sync layer supports client‑side encryption of the database and attachments, with optional per‑note keys derived from a master password.

• Self‑hosting: The sync server can be deployed as a Docker container (joplin/server) or run from source on any Node.js‑capable host. It requires a writable directory for data, a reverse proxy (NGINX/Traefik) for TLS, and optional OAuth2 for authentication.
• Scalability: Because the sync protocol is stateless, multiple instances can run behind a load balancer. The SQLite database is local per instance; data is merged via the sync protocol, so horizontal scaling is limited by the conflict‑resolution strategy.
• Containerization: Official Docker images are available for both the client (via joplin/joplin) and server. Kubernetes manifests are community‑contributed; the API surface is stable enough for automation scripts.

• API: REST endpoints (/api/v1/...) expose note metadata, attachment uploads, and sync status. The API is documented in the docs/api.md file.
• Webhooks: Developers can subscribe to sync events via a simple webhook interface that posts JSON payloads on note changes.
• Themes: The UI accepts CSS overrides; a theme manager in the settings panel lets users load custom stylesheets.
• Scripting: Users can write custom JavaScript snippets that run on startup, enabling automation (e.g., auto‑tagging or scheduled exports).

• Documentation: The project hosts a comprehensive, searchable wiki (docs/) that covers architecture, plugin development, and API usage.
• Community: An active GitHub Discussions forum, a Slack channel, and regular code reviews ensure quick feedback.
• Configuration: All settings are stored in a JSON file (~/.config/joplin/config.json) and can be edited manually or via the CLI.
• Testing: The CI pipeline enforces linting, unit tests, and integration tests before every merge.

1. Enterprise knowledge base – Deploy the sync server on a private cloud; use plugins to enforce compliance tags and audit logs.
2. Personal data sovereignty – Run a local instance on a NAS, sync with Nextcloud, and rely on the encrypted SQLite for offline access.
3. Developer tooling – Use the CLI to export Markdown notes into static site generators (Hugo, Jekyll) or feed them into a continuous‑integration pipeline.
4. Educational platforms – Embed the web clipper in LMS courses to capture lecture notes directly into a shared Joplin instance.

• Performance: Lightweight UI and efficient SQLite queries keep the app snappy even with thousands of notes.
• Flexibility: The