Joplin vs Trilium: Note-Taking Apps Compared

Quick Verdict

Joplin is the better choice if you need encrypted markdown notes that sync reliably across desktop, mobile, and the web. Trilium is the better choice if you treat your notes as a knowledge base — with hierarchical organization, note cloning, and scripting to automate workflows. They solve different problems despite both being “note-taking apps.”

Pick Joplin Server if you already use Joplin’s desktop and mobile apps and want sharing plus admin features on top of sync. Pick Trilium if you want a powerful, self-contained note system you primarily use through the browser.

Overview

Joplin Server is the official sync backend for the Joplin ecosystem. Joplin itself is a desktop and mobile note-taking app built around Markdown and end-to-end encryption. Most users sync via WebDAV or Nextcloud, but the dedicated Joplin Server adds multi-user sharing, an admin dashboard, and a published notes feature. It requires PostgreSQL and runs as a TypeScript/Node.js service.

Trilium Notes (maintained as TriliumNext after the original developer stepped back) is a hierarchical note-taking application with a rich built-in web UI. Notes live in a tree structure where any note can appear in multiple places via “cloning.” It supports rich text, Markdown, code blocks, canvas drawings, and a scripting system that lets you automate note behavior through attributes. It uses SQLite internally and needs no external database.

Feature Comparison

Feature	Joplin Server	Trilium Notes
Primary interface	Desktop + mobile apps	Built-in web UI
Note format	Markdown	Rich text, Markdown, code, canvas
End-to-end encryption	Yes	No (encrypted at rest on disk)
Database	PostgreSQL (external)	SQLite (embedded)
Multi-device sync	Yes — core strength	Yes — server + desktop sync
Note hierarchy	Folders and tags	Tree with unlimited nesting + cloning
Web clipper	Yes (browser extension)	Yes (browser extension)
Note sharing	Yes (published notes, multi-user)	Yes (shared notes via public URL)
Scripting/automation	No	Yes (note attributes, custom widgets)
API	Yes (data API)	Yes (REST API + ETAPI)
Mobile app	Official iOS and Android	No dedicated mobile app (responsive web)
License	MIT	AGPL-3.0
Docker image size	~150 MB	~200 MB
Search	Full-text search across notes	Full-text search with attribute filters
Import/export	Markdown, JEX, ENEX (Evernote)	Markdown, HTML, OPML
Plugins	Yes (desktop plugin ecosystem)	Yes (via scripting and custom widgets)

Docker Compose Setup

Joplin Server

Joplin Server requires PostgreSQL. This Compose file runs both services together.

Create a docker-compose.yml:

services:
  joplin-server:
    image: joplinapp/server:3.2.4-beta
    container_name: joplin-server
    restart: unless-stopped
    ports:
      - "22300:22300"
    environment:
      # Database connection
      - DB_CLIENT=pg
      - POSTGRES_HOST=joplin-db
      - POSTGRES_PORT=5432
      - POSTGRES_DATABASE=joplin
      - POSTGRES_USER=joplin
      - POSTGRES_PASSWORD=changeme-joplin-db-password
      # Application URL — set this to your actual domain
      - APP_BASE_URL=http://localhost:22300
      # Maximum upload size in bytes (200 MB)
      - MAX_NOTE_SIZE=209715200
    depends_on:
      joplin-db:
        condition: service_healthy
    networks:
      - joplin-net

  joplin-db:
    image: postgres:16.6-alpine
    container_name: joplin-db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=joplin
      - POSTGRES_USER=joplin
      - POSTGRES_PASSWORD=changeme-joplin-db-password
    volumes:
      - joplin-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U joplin"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - joplin-net

volumes:
  joplin-db-data:

networks:
  joplin-net:

Start it:

docker compose up -d

Default login is admin@localhost with password admin. Change these immediately after first login at http://your-server:22300.

Trilium Notes

Trilium uses embedded SQLite, so no external database is needed. The setup is simpler.

Create a docker-compose.yml:

services:
  trilium:
    image: triliumnext/notes:v0.91.8
    container_name: trilium
    restart: unless-stopped
    ports:
      - "8080:8080"
    environment:
      # Set your instance name (shown in the UI title bar)
      - TRILIUM_DATA_DIR=/home/node/trilium-data
    volumes:
      - trilium-data:/home/node/trilium-data
    networks:
      - trilium-net

volumes:
  trilium-data:

networks:
  trilium-net:

Start it:

docker compose up -d

Open http://your-server:8080 and set your password on first launch. Trilium generates a random password and shows it in the container logs if you miss the setup screen — check with docker logs trilium.

Note Organization

This is where the two apps diverge most sharply.

Joplin: Notebooks and Tags

Joplin organizes notes into notebooks (folders) with optional tags. A note lives in exactly one notebook but can have multiple tags. This is familiar — it works like email folders or file directories. Notebooks can be nested, but the hierarchy is shallow in practice. Most users rely on search and tags more than folder structure.

The mental model is straightforward: notes are documents, notebooks are folders, tags add cross-cutting organization. If you think in Markdown files and directories, Joplin makes immediate sense.

Trilium: Tree Hierarchy with Cloning

Trilium uses an infinite tree where every note is a node that can contain child notes. The key differentiator is cloning — a single note can appear in multiple places in the tree without duplication. Edit it in one location, and every clone reflects the change.

This matters for knowledge management. Say you have a note about “Docker networking” — it belongs under both your “Docker” branch and your “Networking” branch. In Joplin, you’d pick one folder and add tags. In Trilium, you clone it into both locations and it genuinely lives in both.

Trilium also supports note attributes — key-value metadata on any note that drives behavior. You can mark notes as templates, create automatic sorting rules, or build custom dashboards using Trilium’s scripting engine. This is powerful but comes with a learning curve that Joplin avoids entirely.

Which Approach Is Better?

For capturing thoughts, meeting notes, and personal writing: Joplin’s simplicity wins. For building a structured knowledge base where relationships between ideas matter: Trilium’s tree and cloning system is significantly more capable.

Performance and Resource Usage

Resource	Joplin Server	Trilium Notes
RAM (idle)	~150 MB (server) + ~100 MB (PostgreSQL)	~200 MB
CPU	Low — mostly I/O bound	Low — spikes during search indexing
Disk	Scales with note count + attachments	Scales with note count + attachments
Total footprint	~250 MB RAM with database	~200 MB RAM standalone

Trilium is lighter overall because it bundles SQLite instead of requiring a separate database process. Joplin Server’s PostgreSQL dependency adds operational overhead — you need to manage database backups, monitor connection pools, and handle upgrades separately.

For a single-user setup, Trilium’s self-contained architecture is noticeably simpler to maintain. Joplin Server’s PostgreSQL requirement makes more sense in multi-user deployments where you need the database’s concurrency handling.

Community and Ecosystem

Joplin has a large, active community. The desktop app has a plugin ecosystem with 200+ plugins for everything from backlinks to custom themes. The mobile apps are mature. Evernote migration is well-supported via ENEX import. GitHub activity is strong with regular releases.

Trilium has a smaller but dedicated community. After the original developer reduced involvement, the TriliumNext fork took over active development. The scripting system creates a different kind of ecosystem — users share “note templates” and automation scripts rather than traditional plugins. The community tends toward power users who build elaborate knowledge management systems.

The Joplin ecosystem is broader. The Trilium ecosystem is deeper within its niche.

Use Cases

Choose Joplin Server If…

• You already use Joplin’s desktop and mobile apps and want self-hosted sync
• End-to-end encryption is non-negotiable — Joplin is one of few note apps that does this properly
• You need reliable mobile apps for capturing notes on the go
• You want multi-user support with an admin dashboard
• You prefer writing in Markdown and want a clean, focused editing experience
• You sync notes between many devices throughout the day

Choose Trilium Notes If…

• You are building a personal knowledge base or wiki, not just capturing quick notes
• You want notes that can exist in multiple places in your hierarchy simultaneously
• You value the built-in web interface over dedicated desktop/mobile apps
• You want scripting and automation within your note system
• You prefer a single self-contained service with no external database dependency
• You think in trees and graphs rather than folders and tags

Final Verdict

These are fundamentally different tools that share a category label.

Joplin Server is a sync and sharing backend for a Markdown note-taking app with excellent cross-device support and real end-to-end encryption. It is the right choice for people who want to write notes on their phone, laptop, and tablet with confidence that everything stays in sync and encrypted. The server component adds value primarily through sharing and admin features — if you just need sync, Nextcloud or WebDAV works fine without it.

Trilium Notes is a knowledge management system disguised as a note-taking app. Its tree hierarchy, cloning, attributes, and scripting make it far more powerful for organizing complex information. The tradeoff is no native mobile app and no end-to-end encryption. If you primarily work from a browser or desktop and care more about how your notes relate to each other than about syncing across devices, Trilium is the stronger tool.

For most people who just want a self-hosted replacement for Google Keep or Apple Notes, Joplin is the easier, more practical choice. For people building a second brain or personal wiki, Trilium is worth the steeper learning curve.

Related

• How to Self-Host Joplin Server
• How to Self-Host Trilium Notes
• Best Self-Hosted Note-Taking Apps
• How to Self-Host BookStack
• Docker Compose Basics
• How to Self-Host Outline
• Replace Evernote with Self-Hosted Alternatives