---
title: "tnotes vs Joplin · tnotes"
description: "Joplin or tnotes for Markdown notes? Open-source Evernote-style notes and to-dos with end-to-end encrypted sync, desktop, mobile and terminal clients. Feature-b"
canonical: https://tnotes.app/compare/tnotes-vs-joplin
---

[compare](/compare) / joplin

# tnotes vs Joplin

Open-source Evernote-style notes and to-dos with end-to-end encrypted sync, desktop, mobile and terminal clients.

tnotes

terminal app · macOS, Linux · MIT · free · v1.3.0

[Joplin](https://joplinapp.org)

desktop app · Windows, macOS, Linux, Android, iOS; terminal app on macOS, Linux and WSL (Node.js) · AGPL-3.0-or-later (server package licensed separately) · Free. Joplin Cloud sync from 2.40 €/month (Basic, billed yearly) to 7.99 €/month (Pro 100 GB); self-hosted Joplin Server also available.

Joplin is the open-source answer to Evernote: notebooks, notes and to-dos with attachments, tags and full-text search, imported from ENEX files with their metadata intact. It is offline first, with every client holding a full copy of the data in a local SQLite database and reconciling through a sync target. Sync targets are deliberately pluggable and vendor-neutral: Nextcloud, any WebDAV server, Dropbox, OneDrive, S3, a local folder, or the paid Joplin Cloud, all optionally end-to-end encrypted with a master key you hold.

Notes are Markdown, rendered by a CommonMark pipeline with optional extensions (KaTeX, Mermaid, footnotes, ABC notation). Links between notes use `[title](:/noteid)`, an id-based form that survives retitling; `[[wikilinks]]` and backlinks come from community plugins, not the core. Tags are objects attached to notes rather than words in the text. The desktop editor has a Keyboard Mode setting with Default, Emacs and Vim; the terminal app is a Node.js three-pane TUI with Vim-like normal mode, a `:` command line, and external-editor editing, and its commands (`mknote`, `ls`, `cat`, `set`, `export`, `sync`) also run directly from a shell.

What Joplin is not is a folder of files. The FAQ is explicit that sync directories are “basically just a database” and not meant to be user-editable. To get Markdown files out you export (`--format md` or `md_frontmatter`); to get them in you import. That is the line that separates Joplin from tnotes.

## Feature comparison

| Feature | tnotes | Joplin |
| --- | --- | --- |
| Storage format | ✓ plain .md files, folders are directories | ✗ notes live in a SQLite database in the profile directory; sync targets hold Joplin's own item format, not editable files |
| Runs in the terminal | ✓ TUI (ratatui) plus a headless CLI | ✓ `joplin` terminal app: three-pane TUI with Vim-like normal and `:` command modes |
| \[\[Wikilinks\]\] | ✓ \[\[Title\]\] with completion; rewritten on rename | ✗ links are `[title](:/noteid)`; a community Wikilinks plugin adds \[\[ \]\] |
| Backlinks | ✓ overlay + `backlinks` in JSON | ~ not built in; community plugins (Automatic Backlinks, Backlinks Navigator, Note Link System) |
| #tags | ✓ #tag and nested #work/project, parsed from text | ✓ tags are metadata attached to notes (`tag add`), not `#text` |
| Headless CLI | ✓ ls, search, cat, new, append, write, trash, restore | ✓ shell mode: `joplin mknote`, `ls`, `cat`, `set`, `export`, `sync`, `tag`… |
| JSON output for scripts / agents | ✓ --json on every command | ~ `ls -f json`; Data API (REST on port 41184) speaks JSON when the app runs |
| Live reload on external edits | ✓ file watcher; dirty tabs keep their text | ✗ the database is the source of truth; edits go through the app, CLI or API |
| Vim keys | ✓ vim or emacs keys (edtui) | ✓ desktop: Keyboard Mode → Vim; terminal app is Vim-like and edits in `$EDITOR` |
| Mouse support | ✓ click, double-click, right-click menus, drag | ✓ desktop and mobile apps |
| Sync | ~ any file sync: git, Syncthing, iCloud, Dropbox | ✓ Joplin Cloud, Nextcloud, WebDAV, Dropbox, OneDrive, S3, local folder; `joplin sync` from cron |
| Encryption | ~ encrypt the folder: FileVault, gocryptfs | ✓ end-to-end encryption of synced data on every client (master key + password) |
| Mobile app | ✗ files sync to any mobile Markdown editor | ✓ Android, iOS |
| Plugins | ✗ | ✓ desktop and Android; iOS limited to recommended plugins |
| Open source | ✓ MIT, Rust | ✓ AGPL-3.0-or-later, TypeScript |

✓ yes · ~ partial or via the file system · ✗ no

## Choose Joplin if

-   You need phones and tablets as first-class clients with the same encrypted data, including attachments and to-dos with alarms.
-   You want end-to-end encryption built into sync rather than an encrypted filesystem, and a choice of sync backends including your own Nextcloud.
-   You are migrating from Evernote; the ENEX importer keeps notebooks, tags, resources and metadata, and OneNote import is supported as well.
-   Attachments, images, PDFs and a rendered preview matter as much as the text.
-   You want a plugin ecosystem on desktop and a REST Data API for integrations.

## Choose tnotes if

-   Your notes must be plain `.md` files on disk that git, grep, rsync and other editors can touch directly. Joplin keeps them in SQLite.
-   You want the terminal to be the primary editor, with live Markdown highlighting, `[[link]]` completion and a backlinks overlay built in.
-   Agents and scripts should read and write notes without a running app or an API token: `tnotes ls --json`, `tnotes write --stdin`, and the TUI reloads.
-   You want `[[Title]]` links and `#tags` in the text itself, portable to Obsidian or any Markdown tool.
-   You want a single binary with no Node.js runtime, database or profile directory to manage.

## Using Joplin and tnotes together

There is no live overlap: Joplin’s notes are rows in SQLite and tnotes reads files, so the two never see the same data at the same time. The bridge is export and import.

```
# Joplin → Markdown files → a tnotes root
joplin export --format md ~/joplin-md      # Markdown files, one directory per export
tnotes ~/joplin-md                          # open the export as a tnotes root

# tnotes → Joplin
joplin import --format md ~/Documents/notes "Imported"
```

Use `--format md_frontmatter` if you want Joplin’s metadata preserved as YAML; tnotes will then show `---` as the first line of each note, because its title is the first line and it documents no frontmatter handling. Joplin’s internal links (`[title](:/id)`) have no meaning outside Joplin; rewrite the ones you care about as `[[Title]]`. Joplin tags are not `#tags` in the text, so add `#tag` words for anything you want to filter on in tnotes.

Going the other way, `joplin import --format md` takes a file or a directory and maps the folder structure onto notebooks. The realistic split is to keep Joplin for attachment-heavy or mobile-first notebooks and tnotes for a text vault you script against. See [/docs/cli](/docs/cli) and [/guides/plain-text-notes-sync](/guides/plain-text-notes-sync).

## FAQ

? Does Joplin store notes as Markdown files?

No. Notes are Markdown text, but they are stored in a SQLite database in the profile directory, and the files Joplin writes to a sync target are its own item format. Joplin’s FAQ says a sync directory is ‘basically just a database’. Use `joplin export --format md` to get files; tnotes works on files directly.

? Can I use Joplin from the terminal?

Yes. `npm install -g joplin` gives a terminal app with a three-pane TUI, Vim-like keys and a `:` command line. The same commands work in shell mode (`joplin mknote "Title"`, `joplin ls -f json`, `joplin sync`) for scripts and cron. Editing a note opens your external editor. tnotes edits inline in its TUI and also has a headless CLI.

? Does Joplin support wikilinks and backlinks?

Not in the core. Joplin links are `[title](:/noteid)`, created by dragging a note or ‘Copy Markdown link’. Community plugins add `[[wikilinks]]` (Wikilinks) and backlink panels (Automatic Backlinks to note, Backlinks Navigator, Note Link System). tnotes has both built in and exposes `links` and `backlinks` in `ls --json`.

## Sources

Joplin facts checked on 2026-09-22 against:

-   [Joplin Terminal Application (shell mode, sync, commands)](https://joplinapp.org/help/apps/terminal)
-   [Joplin FAQ (SQLite database, sync directory)](https://joplinapp.org/help/faq)
-   [Joplin Markdown Guide (note links)](https://joplinapp.org/help/apps/markdown)
-   [Joplin Data API](https://joplinapp.org/help/api/references/rest_api)
-   [Joplin End-To-End Encryption](https://joplinapp.org/help/apps/sync/e2ee)
-   [Joplin plugins repository (Wikilinks, backlink plugins)](https://github.com/joplin/plugins)
-   [Joplin Cloud plans](https://joplinapp.org/plans/)
-   [Joplin LICENSE (AGPL-3.0-or-later)](https://github.com/laurent22/joplin/blob/dev/LICENSE)

## Other comparisons

-   [tnotes vs Apple Notes](/compare/tnotes-vs-apple-notes)
-   [tnotes vs Dendron](/compare/tnotes-vs-dendron)
-   [tnotes vs jrnl](/compare/tnotes-vs-jrnl)
-   [tnotes vs Logseq](/compare/tnotes-vs-logseq)
-   [tnotes vs nb](/compare/tnotes-vs-nb)
-   [tnotes vs Neorg](/compare/tnotes-vs-neorg)