Joplin

Joplin is a free, open-source note-taking and to-do application built for users who demand full control over their data. It stores notes in open Markdown format organized into notebooks, supports rich formatting, code blocks, math notation, and embedded media—all editable directly or through an external text editor. The application is “offline first”: your entire note library lives on your device and syncs when connectivity is available.

Joplin supports end-to-end encrypted synchronization across Nextcloud, Dropbox, OneDrive, WebDAV, Amazon S3, and its own Joplin Cloud service. The sync engine handles conflict resolution, delta updates, and versioned item tracking while keeping all cryptographic operations entirely client-side. Notes imported from Evernote (ENEX format) retain formatting, attachments, geolocation, and metadata.

The application ships on Windows, macOS, Linux, Android, and iOS, sharing a common core library across all platforms. A browser Web Clipper extension for Chrome and Firefox saves web pages, screenshots, or selected content as notes with automatic metadata extraction. An extensible plugin system lets developers add custom editors, export formats, commands, and UI panels using a stable JavaScript API.

Recent versions have added AI-assisted note search and chat (supporting Anthropic, OpenAI-compatible providers, and Joplin Cloud AI), a built-in MCP server for integrating Joplin with AI tools, and voice-to-text transcription via Whisper. The result is a self-hostable knowledge base that scales from a single user’s personal journal to a team’s collaborative documentation platform.

What You Get

• End-to-End Encrypted Sync - All notes are encrypted client-side using AES-256-GCM via the Web Crypto API before leaving your device, so no sync provider—including Joplin Cloud—can read your content.
• Multi-Backend Synchronization - Connect to Nextcloud, Dropbox, OneDrive, WebDAV, Amazon S3, or Joplin Cloud with built-in conflict resolution, delta sync, and offline-first operation.
• Evernote Import - Full ENEX import preserving formatted text, inline images, file attachments, geolocation tags, and note metadata, all converted to Markdown with structure intact.
• Web Clipper Extension - Browser extensions for Chrome and Firefox capture entire pages, simplified article views, screenshots, or selected text as notes, extracting resources and metadata automatically.
• Plugin and Theme System - Extend functionality with community or custom plugins via a stable JavaScript Extension API covering commands, editors, UI panels, and export formats; apply CSS themes without touching source code.
• AI Integration and MCP Server - Built-in AI chat and semantic search supporting Anthropic, OpenAI-compatible providers, and Joplin Cloud AI; an embedded MCP server exposes your notes to compatible AI tools.
• Rich Editor Suite - Switch between a CodeMirror-based Markdown editor with live inline rendering, a WYSIWYG Rich Text editor, and external editor integration, with support for math (KaTeX), diagrams (Mermaid), and Fountain screenwriting.
• Cross-Platform Clients - Native clients for Windows, macOS, Linux (Electron), Android and iOS (React Native), and a terminal CLI, all sharing the same encrypted note library through a common TypeScript core.

Common Use Cases

• Private research archive - A security researcher stores sensitive findings and exploit notes in Joplin with E2EE sync to a self-hosted Nextcloud instance, ensuring only they hold the decryption keys.
• Cross-device journaling with media - A writer captures daily notes with voice transcription on their phone, attaches photos, then edits and organizes entries on their Linux desktop using Markdown plugins.
• Web research and clipping workflow - A journalist clips news articles, PDFs, and web pages via the browser extension, tags them by topic, and searches the full-text index offline without internet access.
• Team documentation on self-hosted infrastructure - A small engineering team runs Joplin Server Business on their own VPS, shares notebooks for runbooks and incident notes, and publishes internal wikis via note publishing.
• AI-assisted knowledge management - A product manager uses Joplin’s semantic search and AI chat to query their entire note library, surfacing relevant meeting notes and decisions without leaving the app.
• Developer note-to-code workflow - A developer integrates Joplin’s MCP server with their AI coding assistant to pull context from technical notes and documentation directly into their coding sessions.

Under The Hood

Architecture

Joplin is structured as a Yarn-workspace monorepo spanning roughly two dozen packages, each with clearly bounded concerns: lib holds the entire platform-agnostic core including models, sync engine, search, and E2EE; app-desktop wraps it in Electron; app-mobile in React Native; app-cli exposes it over a terminal interface; and server provides an optional self-hosted sync backend. This strict separation means the same business logic, encryption, and conflict-resolution code executes identically across every client. Communication between layers flows through a centralized event manager rather than direct coupling, keeping UI components decoupled from data layer mutations. The plugin system follows an Open/Closed design: third-party plugins extend capabilities through a versioned JavaScript API without touching core code, and a sandboxed runner prevents plugin failures from crashing the host application.

Tech Stack

The core library is TypeScript running on Node.js, with SQLite (via better-sqlite3) as the local database on desktop and CLI, and a separate PostgreSQL-backed server package for multi-user deployments orchestrated with Docker Compose. The desktop client uses Electron with React and Redux for state management; the mobile client uses React Native with shared @joplin/lib logic. Encryption is implemented using the Web Crypto API (AES-256-GCM, PBKDF2) with a custom EncryptionService that supports multiple versioned encryption method identifiers for forward compatibility. The AI layer supports Anthropic, OpenAI-compatible providers, and Joplin Cloud, with an embedded JSON-RPC MCP server exposing notes as a tool to external AI agents. Build tooling spans Webpack, TypeScript compiler, Lerna for versioning, Crowdin for localization, and GitHub Actions for CI across all platforms.

Code Quality

The codebase maintains extensive test coverage: the lib package alone contains well over 200 test files covering model operations, sync behavior, encryption correctness, conflict resolution, plugin loading, and search accuracy. Tests are organized as co-located .test.ts files running under Jest with thorough assertions on state, side effects, and error paths. Type safety is enforced throughout via TypeScript strict mode, with generated database types and explicit interface boundaries between service layers. Error handling is explicit and typed—custom error classes propagate through async chains with meaningful codes rather than swallowed exceptions. ESLint with project-specific rules and Husky pre-commit hooks maintain consistent style across the entire monorepo. The ongoing JS-to-TS migration (tracked in the repo’s own documentation) reflects a disciplined commitment to reducing technical debt incrementally.

What Makes It Unique

Joplin’s most distinctive technical achievement is its client-side encryption engine: master keys are derived from user passwords via PBKDF2, never transmitted in plaintext, and every item is encrypted before upload regardless of sync target—including the user’s own Joplin Cloud account. The sync engine was built from scratch to support multiple heterogeneous backends through a unified file-API abstraction, handling delta sync cursors, lock management, migration versioning, and conflict merging in a single TypeScript service. The addition of an embedded MCP server is architecturally notable: Joplin’s entire note graph becomes a first-class tool for AI agents, without requiring any external service. The platform-agnostic lib core—identical business logic across Electron, React Native, and CLI—is a rare achievement for a note-taking app of this breadth, and the plugin system’s sandbox isolation and stable API surface have enabled a thriving third-party ecosystem.

Self-Hosting

Joplin’s client applications are licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-or-later), which means you can run, modify, and distribute the app freely. The AGPL’s copyleft provisions require that any modifications distributed to others—or run as a network service—must also be released under AGPL. For most self-hosters running Joplin for personal or internal team use, this has no practical effect. However, the sync server component (packages/server) carries a separate “Joplin Server Personal Use License” that restricts commercial redistribution; self-hosters should review that license if they intend to offer Joplin Server as a service to paying customers.

Running Joplin yourself means you are responsible for the full operational stack. The desktop and mobile clients require no server infrastructure for local-only use. If you want sync, you can point clients at any WebDAV-compatible service, Nextcloud, Dropbox, OneDrive, or Amazon S3—all managed externally. For team collaboration features (shared notebooks, note publishing, user management), you need to deploy Joplin Server, which runs as a Docker container with a PostgreSQL database. You are then responsible for uptime, database backups, SSL termination, storage scaling, and applying software updates. The server application has no built-in high-availability mode, so production deployments require external database replication and reverse-proxy redundancy if uptime guarantees matter.

Joplin Cloud (the managed SaaS offering) provides Basic and Pro tiers with defined storage quotas (2 GB and 30 GB respectively), automated backups, zero infrastructure management, and access to Joplin Cloud AI features. The separately offered Joplin Server Business license targets organizations that need to self-host for data sovereignty while still getting team collaboration features; pricing is available on request. Compared to a self-hosted deployment, Joplin Cloud adds guaranteed uptime, managed upgrades, customer support, and AI-assisted search and chat without requiring any server administration—trade-offs that are material for teams without dedicated DevOps resources.