Taking notes with Joplin

Joplin is an open-source note-taking application designed to handle taking many kinds of notes, whether it is managing code snippets, writing documentation, jotting down lecture notes, or drafting a novel. Joplin has Markdown support, a plugin system for extensibility, and accepts multimedia content, allowing users to attach images, videos, and audio files to their notes. It can provide synchronization of content across devices using end-to-end encryption, or users can opt to stick to local storage only. Joplin even offers a command-line version for terminal-based usage. Joplin 3.2, the most recent feature release, brought long-awaited multi-window support, multi-column layouts, enhanced accessibility, and theme detection.

History

Laurent Cozic started work on Joplin in 2016, with an Android version released in July 2017, and the first desktop release (v0.10.19) made available in November 2017. The complete changelog of the project is available on the Joplin web site. The application is named in honor of ragtime composer and pianist Scott Joplin, whom Cozic admires. More than 650 people have contributed code to the project over its lifetime; based on the activity on GitHub and the steady stream of releases, it is an active and thriving project.

In 2022, Joplin's user applications switched from the MIT license to the GNU Affero General Public License v3 (AGPLv3) with the 2.9 release. The Joplin project also makes its Joplin Server available for users who want to run their own synchronization server. However, that application is released under a source-available, non-free Personal Use License that forbids commercial use and seems to disallow modification as well.

Getting started

Joplin is a multi-platform application, with versions for Linux, macOS, and Windows. It is built with Electron for cross-platform compatibility. Mobile applications are also available for Android and iOS. It is available for Linux as an AppImage from the download page of the web site. The page also provides instructions for installing the terminal application and WebClipper, a browser extension for Chrome and Firefox that allows saving web pages directly to Joplin as notes. The command-line version is not included with the Joplin download, and is installed using Node.js's npm package manager.

Joplin's editor supports writing content in Markdown or using a Rich Text editor for a WYSIWYG experience. However, the project warns that the Rich Text editor has some limitations in working with Joplin plugins that use Markdown. Notes are stored in the Markdown format whether the user chooses the standard Joplin editor or Rich Text editor. All notes, notebooks, and attachments are stored in an SQLite database. Editing with external text editors or file management tools is possible by selecting "Edit with external editor" from the application. However, this approach is only feasible when mediated by Joplin. Directly editing Joplin's notes can disrupt synchronization.

It also offers an export feature that supports multiple formats, including its own Joplin Export Format (JEX), as well as JSON, PDF, and plain Markdown, to back up or transfer data. Similarly, it provides import capabilities, allowing for migration from other note-taking applications. Users can import from JEX, Markdown files, and Evernote data via ENEX files while preserving note structure and attachments.

It includes a to-do list function that allows creation and management of tasks similarly to regular notes. Each to-do item is a special type of note with an additional "completed" status field. When creating a new to-do note, users can assign a title, add detailed content, and set a due date. To-dos can be marked as completed, of course, which updates their status and changes their sorting order in the interface, typically moving completed items to the bottom. Notes themselves can include Markdown to-do lists.

Joplin supports synchronization via a number of FOSS and proprietary synchronization methods. The easiest open-source option is likely Nextcloud, a widely used self-hosted cloud-storage solution, with synchronization via its WebDAV interface. It requires a properly configured Nextcloud instance and authentication credentials. WebDAV support extends beyond Nextcloud, permitting synchronization with any WebDAV-compatible server. This requires manually entering the server URL and credentials.

Joplin offers an account-synchronization feature that allows access from multiple devices and enables note sharing with other users. Joplin Cloud is a paid cloud-storage service. It also supports synchronization methods besides Joplin Cloud, making it possible to choose based on infrastructure and privacy requirements. It also has Dropbox and OneDrive integration, which relies on their respective APIs to store and retrieve encrypted note data from these services. Users must authenticate through OAuth, and Joplin manages synchronization automatically. Each method operates based on Joplin's delta-based sync API, which minimizes data transfer by only updating modified items.

Local filesystem synchronization is another option. This method is suitable for those using external synchronization tools like Syncthing, rsync, or a shared network drive. Since this approach does not involve cloud storage, it offers complete data control but requires additional configuration for multi-device synchronization.

Joplin notes can be encrypted by providing a master password. This gives users end-to-end encryption if they are using any of the synchronization providers. Note that this does not encrypt Joplin's data stored in SQLite or other user data.

Interface and workflow

Joplin's interface is structured as a three-pane layout. The left pane serves as the navigation panel, displaying a hierarchical list of notebooks and sub-notebooks, along with user-defined tags. This panel also provides quick access to synchronization status and configuration settings. The application requires no special configuration, so one can start writing immediately.

The central pane is the note list, where notes within the selected notebook are displayed. Notes are sorted by configurable criteria such as modification date, creation date, or title. Each note entry in this pane includes metadata such as title, timestamp, and an optional preview of the content. Joplin supports both list-based and board-style task management, with drag-and-drop functionality for reordering or changing task states.

The rightmost pane functions as the editor and viewer. This content area dynamically updates based on the selection, showing a list or board-style view of tasks, notes, or documents. Sorting and filtering options allow organization by parameters. Joplin supports multiple editor modes, including a rich-text WYSIWYG editor and a Markdown editor with a split-view preview. The Markdown editor supports CommonMark syntax with extensions for functionality such as checkboxes, footnotes, and mathematical expressions. Code blocks are rendered with syntax highlighting using highlight.js.

The interface includes a toolbar with essential formatting controls, a search bar supporting full-text search with filtering options, and a command palette for quick access to features via keyboard shortcuts. Additionally, Joplin supports a distraction-free mode, which can be activated by toggling individual panes. The entire UI is configurable, with support for themes and a customizable CSS file for further styling adjustments.

The latest version, v3.2.13, contains some minor bug fixes and was released at the end of February 2025. Joplin version 3.2 introduced several new features. The multi-window support allows notes, but not notebooks, to be opened in separate windows. This means users can finally have multiple notes open at a time, which makes it much easier to compare content, cross-reference materials, and organize projects. It may not be immediately obvious how to do this, however, as the option to open new windows is buried in a context menu. To open notes in a separate window, right-click on a note and select the "Edit in…" option. This launches the note in a new, dedicated window for editing or viewing. The feature required significant architectural changes, which included enabling independent operation of multiple windows with synchronized states to ensure real-time updates.

The note list now supports multi-column layouts, allowing sorting and display based on various metadata fields. By selecting "Detailed" as the "Note list style" from the "View" menu, users can view and edit notes along with their metadata (last modification date, completion status, etc.) directly in the central pane.

System theme detection has been implemented, which automatically aligns the application's appearance with the desktop's dark or light theme. In addition to the generic "Light" and "Dark" themes, it is possible to choose from other color combinations, such as "Dracula" or "Solarized Light". Accessibility enhancements include improved keyboard navigation and optimized user-interface contrast. For example, previously, pressing Shift+Tab from the notebook list would cause the focus to jump unexpectedly to the editor. This problem has been addressed by changing the behavior of the shortcut, which now moves focus to the "Add new notebook" button. Moreover, the contrast of scroll bars has been improved, making them more distinguishable.

Developers can extend Joplin's functionality using its JavaScript-based Extension API, which integrates with the Electron framework. The API allows access to core features like note management, UI modification, and data synchronization. Plugins are defined via a manifest file and can be developed using JavaScript or TypeScript. Those already available offer a wide range of features. For example, the Math Mode plugin allows using a note page as a calculator.

Joplin supports drawing functionality through the default inclusion of the Freehand Drawing plugin. It can be used to create and manipulate free-form sketches or annotations directly within the interface, using vector-based rendering. However, its feature set remains limited compared to dedicated graphic-design software.

Joplin's optical character recognition (OCR) feature scans documents like PDFs that are attached to notes. It offers reliable performance for scanning documents with printed text, but is not yet ready for handwritten notes. The project is looking to expand its OCR functionality to support handwritten text recognition. Joplin's OCR yields acceptable results when applied to high-resolution documents with a linear layout. Unfortunately, in real-world scenarios where I have tried to use it, its usefulness has been limited for documents that have complex formatting like tables. Users may have better luck with other OCR systems on Linux that perform better than Joplin's built-in system, though it is convenient to have an integrated option.

The Help section of the Joplin web site and the Discourse forum serve as good starting points to find help, if needed.

Drawbacks

Joplin has several limitations that may impact its usability, performance, and extensibility. Since it is based on Electron, Joplin has higher resource consumption compared to native alternatives. Memory usage can be high compared to native applications, especially when handling large note collections or extensive synchronization operations. For example, Joplin consumes more than 500MB of RAM right after startup on my system according to Ubuntu's System Monitor. Joplin may feel sluggish on lower-end or older hardware due to Electron's overhead.

Synchronization, though flexible, depends on external storage providers or self-hosted solutions. Performance varies based on the selected backend, with WebDAV implementations often experiencing latency issues due to inconsistent server performance. Joplin's delta-based sync mechanism reduces data transfer, but initial synchronization of large note sets can be slow. Additionally, its conflict resolution is limited, requiring manual intervention when multiple edits occur on different devices before synchronization.

The WYSIWYG editor can introduce inconsistencies when switching between rich text and Markdown modes, particularly for complex formatting structures. Table editing is limited, requiring manual adjustments in Markdown mode. Joplin's plugin ecosystem faces limitations due to the constraints imposed by the underlying Electron framework, which affect the scope and performance of potential extensions.

Development

As an Electron application, Joplin is mostly written in JavaScript and TypeScript. The project releases three major versions per year and has a roadmap with feature-freeze dates and tentative release dates through May 2027, though the roadmap does not indicate specific features planned for those versions. The development approach is adaptive, with priorities shaped by user feedback, pull requests, and community discussions. This means that while major release dates are scheduled, the exact features and improvements included in each version are determined closer to their release.

When a new stable release of Joplin is published, older versions do not receive further updates. So, for example, the 3.2.x line is still receiving updates, and 3.3.x is the development branch. The 3.1.x versions are no longer being updated. The Contributing to Joplin page provides a starting point for contributing. There, users can choose an area to get involved in.

To enable access to pre-releases, navigate to the Configuration menu, open the "Application" section, and enable the option labeled "Get pre-releases when checking for updates". Bugs encountered in pre-release versions can be reported either on GitHub or the Joplin forum. The latest Joplin desktop pre-release, version 3.3.3, focuses on accessibility, performance, and usability improvements. Key updates include new features such as multiple instance support, an upgrade to Electron 35.0.1, and various bug fixes.

Conclusion

While Joplin provides flexibility, performance can vary depending on the synchronization method, and users may have problems with delayed content updates across devices. The interface is functional, supporting both Markdown and rich-text editing, but it may feel less polished or intuitive compared to proprietary alternatives like Obsidian. The plugin system is still developing, and mobile performance can be limited. Overall, Joplin is a solid choice, but users may encounter a few rough patches depending on how they use the application.