Open-source personal knowledge management, honestly reviewed. No marketing fluff, just what you get when you build your second brain on a server you control.

TL;DR

What it is: AGPL-3.0 hierarchical note-taking application for building personal knowledge bases — think Evernote meets a local database with scripting built in [2][3].
Who it’s for: Researchers, writers, and self-hosting founders who need a fast, private, deeply linked knowledge base and are tired of Notion’s loading spinners or Evernote’s subscription creep [3].
Cost savings: Evernote Personal runs ~$130/year, Notion Plus ~$120/user/year. TriliumNext self-hosted runs on a $5/mo VPS — or entirely free if you only use the desktop app [3][4].
Key strength: Genuinely fast local storage, a tree structure that handles 100,000+ notes without slowing down, and a fork story that has already proven the community won’t let it die [2][3][5].
Key weakness: AGPL-3.0 license (not MIT), no native mobile app, no real-time collaboration, and the UI is functional but not beautiful — this is a power-user tool, not a beginner-friendly one.

What is TriliumNext Notes

TriliumNext Notes is a hierarchical note-taking application built around the idea that a personal knowledge base should be a local database, not a cloud service. Notes organize into an arbitrarily deep tree, every note can live in multiple branches simultaneously (“clones”), and the whole thing stores in an SQLite file on disk. No servers required unless you want sync [3][5].

The project has an unusual origin story. Trilium Notes was originally built by a single developer known as Zadam, who grew it to 22,000+ GitHub stars over two years of active development. In January 2024, Zadam announced the project would enter maintenance mode — bug fixes only — because of major life changes: a new child and increased work demands. A community member named Elian Doran refused to accept that. He forked the project as “TriliumNext,” started shipping new features, and then embarked on what is almost certainly an unprecedented campaign to recover the original repository [2].

The TriliumNext team found every email address Zadam had ever signed a commit with, including a corporate address, and persisted for nearly a year. It paid off: Zadam transferred the original 22,000-star repository to the TriliumNext team. The fork’s 2,700 stars merged into the original’s community, and the project now sits at 35,088 stars — more than 50% growth since the handover [2].

The reason this history matters: when you pick a self-hosted tool you’re betting on the project’s longevity. TriliumNext has already survived the scenario that kills most open-source projects (creator abandonment) and came out the other side with more contributors than before.

Why people choose it

The two XDA Developers reviews give the clearest picture of who ends up here and why.

The Notion refugee argument. The XDA review by Beatrice Manuel [3] is not a theoretical comparison — she actually migrated her entire knowledge vault from Notion to TriliumNext after years of use. Her core complaint against Notion: every action required a round-trip to a remote server. For someone with 2,000+ notes jumping between cross-references during a meeting, three-second load times became an unconscious avoidance pattern. TriliumNext runs entirely on the local machine. Note retrieval is in milliseconds, not seconds [3].

The practical translation: Notion is the tool for team wikis and project management. TriliumNext is the tool for a single person’s rapidly-growing knowledge base. If your use case is “my brain extended into software,” local storage wins.

The Evernote replacement case. The pricing math is brutal for Evernote at scale. Evernote’s free tier caps at 60MB of uploads per month and syncs to only one device. Their Personal plan runs around $10.99/mo billed annually ($130/year). Their Professional plan runs around $14.99/mo ($180/year). Beyond that, you’re on Teams pricing. TriliumNext’s desktop app is free forever with no account. Self-hosted sync adds the cost of a VPS. For anyone past the free tier, the gap is obvious [merged profile].

The Obsidian adjacent case. TriliumNext isn’t Obsidian’s direct competitor — Obsidian is file-based Markdown and TriliumNext is database-backed — but they appeal to similar people. The tradeoff: Obsidian’s plain-text Markdown means your notes are always portable. TriliumNext’s SQLite database means features like clones (one note in multiple tree locations without duplication) and scripting that simply aren’t possible with flat files. One reviewer explicitly describes it as combining “Notion’s flexibility with Obsidian’s speed” [3].

Features: what it actually does

Core note structure:

Notes arranged in an infinitely deep tree; no separate “folders” concept — every note can have child notes [5]
Clones — a single note can exist at multiple places in the tree simultaneously, with changes reflected everywhere. Solves the problem of notes that belong in multiple categories without duplicating content [3][5]
Note attributes (labels and relations) for organization, querying, and linking notes to each other [5]
Full-text search with filtering by parent note or depth [website]
Note hoisting — temporarily narrows the visible tree to a specific branch, creating virtual workspaces [website]

Note types:

Rich WYSIWYG text editor with tables, images, math expressions, code blocks, and Markdown autoformat shortcuts [5]
Code notes with dedicated editor and syntax highlighting for many languages [website]
Canvas notes powered by Excalidraw — sketches and diagrams on an infinite canvas [5][website]
Mind maps (Mind Elixir), relation maps, Mermaid diagrams, geo maps [website][5]
File/attachment notes with in-app PDF and media preview [website]
Kanban boards, calendar views, table views — full project and task management without leaving the app [website]

Technical depth:

Scripting via JavaScript with access to the full note API — build custom widgets, automate workflows, generate computed notes [5]
REST API for external automation [5][website]
Note versioning with automatic periodic snapshots and on-demand revisions [5]
Per-note encryption with password-protected sessions for sensitive material [5]
Web clipper browser extension to save pages directly into the tree [website]

Sync and access:

Sync to a self-hosted server; third-party sync hosting options also documented [5]
Mobile access via web browser or PWA (no native app, but an unofficial Android app “TriliumDroid” works offline) [website]
Touch-optimized mobile frontend [5]
Note sharing — publish a subset of notes to the public internet via your server [5][website]

Auth and security:

OpenID and TOTP (two-factor authentication) for server login [5][website]
Scales to 100,000+ notes without performance degradation [5]

Pricing: SaaS vs self-hosted math

Evernote (SaaS competitor):

Free: 60MB/month upload limit, sync to one device, no offline notebooks on mobile
Personal: ~$10.99/mo (billed annually, ~$130/year)
Professional: ~~$14.99/mo (~~$180/year)
Teams: ~$24.99/user/month

Notion for comparison:

Free: limited blocks for personal use
Plus: $10/user/month (~$120/year)
Business: $18/user/month

TriliumNext self-hosted:

Software: $0 (AGPL-3.0) [merged profile]
Desktop app (local only, no server): $0, runs on Windows/macOS/Linux
VPS for sync server: $4–6/mo on Hetzner or Contabo
Your time: 5 minutes for desktop install, 20–60 minutes for Docker server [3][4]

Concrete savings for a typical user:

If you’re on Evernote Professional at ~$15/mo, that’s $180/year. Self-hosted TriliumNext on a $5 Hetzner VPS: $60/year. Save $120/year with unlimited storage, no upload caps, and zero note count limits. If you only need single-device local storage and no sync, the desktop app is permanently $0 — saving the full $180.

If you’re a team of three on Notion Business at $18/user/month, that’s $648/year. TriliumNext doesn’t do real-time collaboration, so this comparison breaks down — but if each person wants their own knowledge base rather than a shared wiki, three TriliumNext desktop installs cost $0.

The caveat: Evernote and Notion include search indexing, mobile apps, and support. TriliumNext delivers none of those by default and requires you to manage your own data.

Deployment reality check

The XDA guide [4] and the Beatrice Manuel review [3] both make the point that “self-hosted” sounds harder than it is for TriliumNext.

Desktop app (simplest path):

Download executable from GitHub, run it. Five minutes. Notes stored locally in SQLite [3][4].
No Docker, no server, no domain. Works completely offline.
Limitation: notes exist on one machine. Sync requires a server.

Docker (server, recommended):

docker pull triliumnext/notes
docker run -t -i -p 8080:8080 -v ~/trilium-data:/home/node/trilium-data triliumnext/notes

Access via browser at your IP and port 8080 [4]. The XDA guide walks through the full setup including Proxmox LXC container deployment via a single community script.

Proxmox LXC (if you run a home lab): One bash command from the tteck Proxmox helper scripts installs it into a lightweight LXC container automatically [4]. Proxmox users won’t find an easier deployment.

What you actually need for the server path:

A Linux VPS or home server with 512MB–1GB RAM (it’s lightweight)
Docker installed
A domain name and reverse proxy (Caddy works well) for HTTPS
Optional SMTP for notifications

What can go sideways:

The AGPL-3.0 license means if you embed TriliumNext in a commercial SaaS product or distribute it as part of a hosted service, you must open-source the modifications. This is different from MIT. Read the license before building a business on top of it.
No native Android or iOS app. The PWA works but isn’t as polished as a dedicated app. The unofficial TriliumDroid app for Android fills part of this gap but it’s not official and could lag behind [website].
Sync requires you to run a server. If you want notes on your phone without a VPS, you’re stuck with the PWA or TriliumDroid.
The UI is functional and information-dense — this is not a consumer product. The learning curve for the tree structure and attribute system is real. One XDA reviewer explicitly calls the mental model shift the biggest barrier, not the technical complexity [3].
AGPL requires that any public-facing server running TriliumNext with modifications must publish those modifications. For personal self-hosting this is irrelevant; for a startup building on top of it, this is a real constraint.

Realistic time estimate: 5 minutes for a desktop install. 20–40 minutes for Docker on an existing VPS. 60–90 minutes including domain setup, HTTPS, and first-sync configuration.

Pros and cons

Pros

Genuinely local-first performance. Notes open in milliseconds, not seconds. No loading spinners, no “Connecting…” notifications. Multiple reviewers single this out as the feature they didn’t know they needed until they had it [3].
Clone-based organization. A single note in multiple tree branches without duplication is a fundamentally better solution to cross-category information than tags or copies. No other mainstream note app does this as cleanly [3][5].
Scales to 100,000+ notes. The SQLite backend doesn’t slow down at scale the way web-based tools do. Designed for people who actually accumulate knowledge over years [5].
Scripting and REST API. Not just a note-taking app — a programmable knowledge base. Custom widgets, automated note generation, external integrations via REST [5][website].
Full note versioning. Automatic snapshots plus on-demand revisions. You cannot accidentally lose a note without recovery options [5].
The project survived abandonment and came back stronger. 35,088 stars, active development, community-managed — the risk of “creator disappears” has already been tested and the project passed [2].
Per-note encryption. Sensitive notes can be encrypted individually, not just the whole database [5].
Completely free desktop app. No account, no SaaS dependency, no upload limits. If you only need one device, the cost is literally zero [3].

Cons

AGPL-3.0, not MIT. If you’re a developer who wants to embed this in a commercial product, the copyleft terms are a real constraint. Read the license. This is a meaningful difference from tools like Activepieces (MIT) [merged profile].
No native mobile app. PWA and an unofficial Android app are the options. For serious mobile note-takers, this is a blocker [website].
No real-time collaboration. This is a single-user tool. One sync server can serve multiple accounts, but collaborative editing (multiple cursors, live changes) doesn’t exist [3].
The UI is dense. Power-user aesthetic, not consumer product design. Notion converts will notice the difference immediately. The tree-first model also has a learning curve [3][4].
Sync requires self-managed infrastructure. There’s no hosted sync tier you can pay for — TriliumNext is entirely self-hosted. Third-party cloud hosting options are documented but not official [5].
The fork story, while inspiring, is also a warning. The original project entered maintenance mode with 22,000 stars. TriliumNext has succeeded so far, but it’s a small team managing a complex application. Community sustainability is a real long-term question [2].
No LLM/AI integration out of the box. No AI writing assistant, no semantic search. You can wire it up via the REST API or scripting, but nothing ships by default.

Who should use this / who shouldn’t

Use TriliumNext if:

You have 500+ notes and Notion’s loading times are affecting how often you actually open your knowledge base.
You’re paying Evernote more than $10/mo and primarily use it for personal research — the self-hosted math is obvious.
You want your notes in a local database under your control, not on someone else’s server.
You’re a researcher, writer, or analyst who builds cross-referenced knowledge over years and needs something that scales without getting slow.
You’re comfortable with (or willing to learn) basic Docker, or you’ll use the desktop app and not need a server.
You want scripting capabilities inside your note app — not just formatting, but actual automation.

Skip it (pick Obsidian instead) if:

You want plain Markdown files you can read with any text editor in 10 years. TriliumNext’s SQLite database is portable but not universally readable.
You live in a plugin ecosystem — Obsidian’s plugin library is one of the largest in the PKM world.
You want native mobile apps with offline support.

Skip it (stay on Notion) if:

You’re collaborating with a team in real time on shared documents.
You build wikis, product specs, or project databases with multiple contributors.
You’re not ready to think about where your data lives.

Skip it (use Logseq or Roam) if:

Your primary workflow is daily notes with bidirectional links and graph visualization.
You want outliner-first, block-based organization rather than tree-first.

Skip it (stay on Evernote) if:

You rely heavily on the Evernote mobile app for quick capture and offline access.
Your team is on Evernote Teams and you need shared notebooks.

Alternatives worth considering

Obsidian — plain Markdown files, massive plugin ecosystem, native mobile apps, local-first. Free for personal use; Sync ($10/mo) and Publish ($20/mo) add-ons available. No scripting against the data model, no clones, no built-in collaboration.
Logseq — open-source, outliner-first, daily notes with graph view, block-level bidirectional links. Free and local-first. Less suited for deeply hierarchical reference material.
Joplin — open-source Markdown note app with E2E sync. Simpler than TriliumNext, Markdown-native. For people who want Evernote import and standard folders without the complexity.
Notion — the obvious cloud alternative. Team collaboration, databases, wikis, kanban. Closed source, internet-dependent, per-user pricing at scale.
Evernote — the incumbent. Mature mobile apps, best-in-class web clipper, search across scanned PDFs. Worth it only if you’ve been on it for years and can’t migrate your archive.
Outline — open-source team wiki, not personal PKM. If you need shared documentation rather than a personal knowledge base.
SiYuan — newer, AGPL, local-first, block-based like Notion with self-hosted sync. Worth watching but smaller community.

For a non-technical founder choosing between these: Notion if you need shared team workspaces; Obsidian if you want plain files and a plugin ecosystem; TriliumNext if you want maximum power and speed for a personal knowledge base you own completely.

Bottom line

TriliumNext Notes is what happens when a community refuses to accept that a great tool has to die. The project has more stars now than when the original creator walked away, and it’s gained enough institutional memory — in the form of contributors, documentation, and maintained infrastructure — that the single-point-of-failure risk has genuinely diminished. The product itself is a serious personal knowledge management tool: local-first speed, hierarchical organization that scales to hundreds of thousands of notes, per-note encryption, scripting, and a REST API. The trade-offs are real: no native mobile app, no team collaboration, an AGPL license that matters if you’re building commercially on top of it, and a UI that rewards patience rather than first impressions. For a solo founder or researcher paying $130–$180/year to Evernote for single-user note storage, the math is straightforward. Download the desktop app, migrate your notes, and the subscription disappears. If you need sync, add a $5 VPS later.

Sources

Dosu.dev — “How TriliumNext Revitalized an Abandoned Open Source Project with Dosu’s Help”. https://dosu.dev/blog/how-triliumnext-revitalized-an-abandoned-open-source-project-with-dosus-help
Beatrice Manuel, XDA Developers — “I finally replaced Notion with a self-hosted knowledge base built on Trilium Next” (Nov 2, 2025). https://www.xda-developers.com/trilium-next-notion-alternative/
Ayush Pande, XDA Developers — “I built a personal knowledge management hub using TriliumNext Notes — here’s how” (Oct 31, 2024). https://www.xda-developers.com/triliumnext-notes-guide/
MyQNAP — “Trilium Notes (QMultimedia Q6) (QTS6/Hero6)”. https://www.myqnap.org/product/trilium-notes-qmultimedia-q6-qts6-hero6/