How to Use TriliumNext: The Beginner's Guide (Install, First Note Tree, and the Backup Rule)

CodexFuse Team · 2026-11-01T02:21:15.878Z · 13 min read

TriliumNext is the community fork of Trilium Notes. This beginner's guide covers the Docker install, the fork lesson, your first note tree, labels and relations, per-note encryption, templates, sync, and the document.db backup rule.

What is TriliumNext, exactly?

TriliumNext is the community-maintained fork of Trilium Notes, an open-source hierarchical note-taking application for building large personal knowledge bases. If you are looking for a TriliumNext tutorial for beginners, start with this mental model: every note lives in a tree, that tree can be as deep as you like, and a single note can appear in several branches at once through cloning. This guide covers how to use TriliumNext end to end — install, first note tree, and the backup rule that protects everything you write.

The fork exists because the original Trilium author, zadam, placed his project in maintenance-only mode (documented in GitHub issue #4620) and eventually handed the repository to the community. The active line now lives at TriliumNext/Trilium on GitHub, carries the AGPL-3.0 license, and had its most recent stable release, v0.106.1, on 2026-10-23, with the codebase pushed as recently as 2026-10-31. The whole application runs on SQLite plus Node.js, and the project claims the engine stays snappy past 100,000 notes.

Before you install anything, decide which shape of TriliumNext you want. As a self-hosted notes app, it gives you two parts: a server that holds everything and clients that sync to it. For open-source note taking without a vendor holding your data, most beginners should run the server in Docker (the Docker beginner guide covers the engine itself) and reach it from any browser, then optionally add the desktop client for daily writing.

Trilium vs TriliumNext: the fork lesson

The fork lesson is simple: do not follow pre-2024 Trilium guides for installation commands, because the project renamed itself and its Docker images in the process. The old image name was triliumnext/notes, which still exists on Docker Hub with around 3 million pulls and was last updated on 2026-10-01; the newer, more-downloaded image is triliumnext/trilium, with around 5.6 million pulls and an update on 2026-10-31.

The official wiki still documents the triliumnext/notes path, so that route is supported and safe. The key compatibility fact, from the official Docker Hub readme: TriliumNext versions up to and including v0.90.4 are compatible with the last zadam/Trilium release (v0.63.7); later TriliumNext versions bumped the sync protocol version, which prevents direct database migration from the old line. If you are migrating an old Trilium database, upgrade zadam/Trilium to its final release first, then install TriliumNext — and check the current wiki's migration notes before jumping to the very latest version.

Practically, none of this changes the beginner path: you install fresh, you get the current release line, and the fork's new features (modernized stack, OpenID Connect, TOTP login, encrypted automatic backups) are the reason to pick TriliumNext over the frozen original.

How do I install TriliumNext on a server?

The official docs recommend the Docker route, and this seven-step arc is the fastest verified TriliumNext install path to a working server. The TriliumNext Docker setup below assumes you have a VPS or home server with Docker installed and SSH access — the usual what is VPS hosting shape.

1. Grab the official compose file. The wiki publishes it from the TriliumNext/Notes repository's master branch: wget https://raw.githubusercontent.com/TriliumNext/Notes/master/docker-compose.yml. Using the project's own file beats copying a random compose snippet from a forum.
2. Check what the compose file pins. Open it and look at the image tag. The official wiki warns against blindly using the latest tag, because an automatic minor-version upgrade can break sync setups between your clients. Pin a version tag such as v0.106.1 for a stable beginner setup.
3. Prepare the data directory. The container expects a host directory mounted at /home/node/trilium-data with write permissions. The default is ~/trilium-data on your host — create it before starting.
4. Start the container. Run docker compose up -d in the directory holding the compose file. Verify with docker ps.
5. Open the web UI. Point a browser at http://<server-ip>:8080. TriliumNext's server interface works best in current Chrome or Firefox, per the official docs.
6. Pick "I'm a new user." The first-run screen offers this option; choose it and set your server password. This password protects the whole server — write it down somewhere safe, because there is no password-reset email on a self-hosted box.
7. Confirm the database file exists. On the host, check ~/trilium-data/document.db. That single SQLite file is your entire knowledge base, and knowing where it lives is the foundation of the backup lesson later in this guide.

Two operational notes from the official wiki: the container requires root privileges to operate correctly, and if timestamps look wrong inside the app, set the TZ environment variable to your timezone identifier. This TriliumNext for beginners walkthrough keeps the defaults everywhere else, so you can get to writing within ten minutes of the container starting.

What happens on first login?

On first login you set the server password, and that password is effectively the key to your whole knowledge base. TriliumNext treats the server as the source of truth for everything — notes, attributes, and sync state — so the first password you create is the most important credential in the system.

After login you land on a mostly-empty note tree with demo content under a Trilium Demo folder. Do not skip the demo folder: it contains scripting examples and default templates that teach the app's deeper features faster than any external tutorial. Explore it before you delete it, then start building your own tree.

How do I build my first note tree?

Your first note tree should mirror how you actually think, not how a file system looks. Create a top-level note for each area of your life or work — for example "Projects", "Reading", "Journal", "Reference" — then nest children under each. Notes can be text, code notes with syntax highlighting, mind maps, canvases for sketching, books (parents that collect children), web views, files, and images.

The feature that separates TriliumNext from plain folder-based note apps is cloning: one note can live in several branches of the tree at the same time. A "Weekly review" note can sit under both "Journal" and "Projects" without being duplicated — edit it in either place and both views update, because there is only ever one note. Use cloning for anything that belongs to two contexts at once, and your tree stays shallow instead of sprawling.

A practical starter set for week one: a "Journal" book with daily notes, a "Projects" book with one child per active project, an "Inbox" note where quick captures land before you file them, and a "Reference" book for saved articles and clippings. You can reorganize freely later — moving notes never breaks their links, because TriliumNext references notes by internal ID, not by path.

What are labels and relations in TriliumNext?

Labels and relations are TriliumNext's answer to tagging, and they are more powerful than hashtags. A label is a key=value attribute on a note (for example #status=active or #priority=high); a relation is a key pointing at another note (for example ~author=Note(Jane Smith)). Together they form a queryable graph layered on top of the tree.

Here is a concrete starter set you can apply in your first week:

• #type=book on any note that is a long-form writeup, so you can later search "all books I wrote this year".
• #status=active / #status=someday on project notes, so one saved search shows everything on your plate.
• ~dependsOn=Note(Project X) on a task note, building a lightweight dependency map across projects.
• #rating=5 on reading notes, giving you a personal "best of" shelf with a single query.

The payoff: search in TriliumNext understands attributes, so a query like #status=active AND #priority=high returns exactly your current focus list, no manual curation needed. Spend fifteen minutes adding labels when you create notes, and the app starts behaving like a personal database instead of a pile of documents.

How does TriliumNext encryption work?

TriliumNext encryption is per-note, and it is the app's standout privacy feature: you can encrypt individual notes while the rest of the database stays readable. Right-click any note and choose Protect; the note's content is then encrypted with your protected-session password.

When the protected session times out, protected notes become unreadable until you re-enter the password — the titles stay visible but the bodies lock. This granularity is the point: your journal entries and credentials notes can be encrypted while your project outlines stay searchable, all inside one database. For whole-server security, add TOTP two-factor login (supported per the official feature list) and keep the server behind HTTPS, covered later in this guide.

How do templates work in TriliumNext?

Templates remove the friction of starting similar notes. Mark any note with the #template label and it becomes available as a starting point whenever you create a child note — TriliumNext asks which template to use and pre-fills the new note's content and attributes.

Build one template per repeating note type. A "Book notes" template might pre-fill title, author, status, and rating fields; a "Meeting" template might pre-fill date, attendees, and an action-items checklist; a "Daily journal" template might pre-fill the date and three prompt headings. Combined with labels, templates turn note creation into filling in a small form, which is how a knowledge base stays consistent enough to query later.

How does TriliumNext sync work with the desktop client?

TriliumNext sync follows one hard rule: the server is the source of truth, and the desktop client syncs to it. Download the desktop binary for your platform from the release page, unzip it, and run the trilium executable. On first start, choose "connect to existing sync server" and point it at your server.

The desktop client is the recommended daily driver — better keyboard shortcuts, offline-first behavior, and a fuller editing experience than the web UI. Changes sync to the server, and from there to your other clients. Because the server holds the canonical database, you can wipe and re-pair a client at any time without losing data, as long as the server's document.db is intact.

On mobile, the current state is honest and limited: there is no finished native mobile app yet (tracked in the project's issue #72; an experimental Android client called TriliumDroid exists). The supported path is your phone's mobile browser pointed at the server's mobile frontend. Plan your mobile usage as read-mostly until the native clients mature.

How do I back up TriliumNext?

The backup rule for TriliumNext is one sentence: back up document.db, not just the container. Everything — notes, attributes, encryption state, sync history — lives in that single SQLite file at /home/node/trilium-data/document.db inside the container, which maps to your host's data directory (default ~/trilium-data).

A minimal backup routine looks like this:

• Daily file copy: cp ~/trilium-data/document.db ~/backups/trilium-$(date +%F).db — stop the container first for a guaranteed-consistent copy, or copy while running and verify the copy opens.
• Off-machine copy: sync the backup directory to another machine or cloud storage, so a dead VPS does not take your notes with it.
• Restore test: once a month, copy a backup to a scratch directory, start a second container against it, and confirm your notes open. An untested backup is a rumor.

TriliumNext also ships automatic encrypted backups on a schedule, but treat those as a second layer — your own dated copies of document.db are the ones you control. Backing up the Docker volumes or the container image without the database file backs up nothing that matters. That single-file design is what makes TriliumNext a genuinely self hosted notes app: your server, your database, your rules — the promise of open source note taking without a vendor in the middle.

How do I put TriliumNext behind HTTPS?

Do not expose port 8080 to the internet without a reverse proxy and TLS — your notes deserve HTTPS. The official docs cover nginx and Apache configurations; the simplest beginner path is Caddy, which gets certificates automatically. A single Caddyfile block does it:

notes.example.com {
    reverse_proxy 127.0.0.1:8080
}

Run the TriliumNext container bound to localhost only (-p 127.0.0.1:8080:8080 in the compose file), let Caddy terminate TLS, and keep the raw port unreachable from the outside. The Caddy beginner guide walks through the full setup if you have never configured a reverse proxy before.

TriliumNext vs Joplin vs Logseq vs Outline

TriliumNext is not the only self-hosted notes app, so here is where it sits against the three names beginners compare it with most. This table is an original synthesis of each project's documented shape:

The dividing line: TriliumNext is the pick when one person wants a deep, scriptable, encrypted knowledge base they fully own; Outline wins when a team needs shared docs with permissions; Joplin and Logseq win when you want your notes as plain files you can walk away with.

Sources

• TriliumNext/Trilium GitHub repository and releases API — latest release v0.106.1 (2026-10-23), ~38,635 stars, AGPL-3.0, pushed 2026-10-31
• TriliumNext official documentation — Docker server installation wiki (crawled 2026-11-01): compose file, version-pinning warning, data directory, root-privilege and TZ notes
• Docker Hub — triliumnext/notes (~3M pulls, updated 2026-10-01) and triliumnext/trilium (~5.6M pulls, updated 2026-10-31); official readme: maintenance-mode handoff, 100,000+ notes, Evernote import, web clipper, OIDC + TOTP, v0.90.4 migration compatibility line
• XDA Developers — TriliumNext notes guide (Oct 2024): Proxmox/Docker install arcs, "I'm a new user" first-run flow, server password setup
• amireslampanah.com — Trilium hierarchical notes deep-dive: mental model, labels/relations syntax, #template, right-click Protect encryption, server-as-source-of-truth sync, Caddy reverse proxy
• blog.brightcoding.dev — TriliumNext Notes editorial (updated ~8 days before this guide): fork history, first stable under the new banner (September 2025), document.db backup path, TriliumDroid experimental Android client

Frequently Asked Questions

Is TriliumNext really free?

Yes. TriliumNext is open source under the AGPL-3.0 license — no paid tiers, no feature gates, no account required. Your only cost is the server you run it on, which can be a $5 VPS or a Raspberry Pi on your desk.

What is the difference between Trilium and TriliumNext?

Trilium was the original app by zadam; TriliumNext is the community fork that continues it after the original entered maintenance mode and the repository was handed to the community. For new installs, always choose TriliumNext — it is the actively developed line, currently at v0.106.1.

Which Docker image should I use, triliumnext/notes or triliumnext/trilium?

Both are official. The documentation currently walks through triliumnext/notes, while triliumnext/trilium is the newer, more-downloaded image updated most recently. Follow the official wiki's compose file for your first install, and pin a version tag rather than using latest if you plan to sync desktop clients.

Can I use TriliumNext on my phone?

There is no finished native mobile app yet — the supported path is your phone's browser pointed at the server's mobile web interface. Treat mobile as read-mostly for now and do your heavy writing on desktop.

What is the one backup I must never skip?

The document.db SQLite file in your data directory. Copy it daily to a second location and test a restore monthly. Everything else — containers, images, compose files — is replaceable; document.db is your knowledge base.