Top Related Projects
A personal knowledge management and sharing system for VSCode
A privacy-first, open-source platform for knowledge management and collaboration. Download link: http://github.com/logseq/logseq/releases. roadmap: http://trello.com/b/8txSM12G/roadmap
A privacy-first, self-hosted, fully open source personal knowledge management software, written in typescript and golang.
CLI and local web plain text note‑taking, bookmarking, and archiving with linking, tagging, filtering, search, Git versioning & syncing, Pandoc conversion, + more, in a single portable script.
Build your personal knowledge base with Trilium Notes
Quick Overview
Dendron is an open-source, hierarchical note-taking application built as a Visual Studio Code extension. It combines the flexibility of a markdown editor with the organization of a hierarchical file system, allowing users to create, manage, and navigate complex knowledge structures efficiently.
Pros
- Powerful hierarchical organization system for notes
- Seamless integration with Visual Studio Code
- Extensive plugin ecosystem and customization options
- Built-in support for backlinks, tags, and graph visualization
Cons
- Steep learning curve for new users
- Requires Visual Studio Code, which may not be preferred by all users
- Limited mobile support compared to some other note-taking apps
- Performance can slow down with very large vaults (collections of notes)
Getting Started
- Install Visual Studio Code
- Open VS Code and navigate to the Extensions view
- Search for "Dendron" and click "Install"
- Once installed, click "Create Workspace" in the Dendron: Welcome screen
- Choose a location for your Dendron workspace
- Start creating notes using the "Dendron: New Note" command (Ctrl+L)
Example of creating a new note with Dendron:
---
id: root
title: Root
desc: ''
updated: 1621234567890
created: 1621234567890
---
# Welcome to Dendron
This is your root note. You can start organizing your thoughts from here.
## Getting Started
To create a new note:
1. Use the command palette (Ctrl+Shift+P)
2. Type "Dendron: New Note"
3. Enter a name for your note
[[Your-First-Note]]
This example shows the basic structure of a Dendron note, including frontmatter and markdown content. The double brackets [[]] create a link to another note.
Competitor Comparisons
A personal knowledge management and sharing system for VSCode
Pros of Foam
- Lightweight and minimalistic approach, focusing on core note-taking features
- Seamless integration with Visual Studio Code, leveraging its existing ecosystem
- More flexible and customizable, allowing users to adapt it to their workflow
Cons of Foam
- Less structured organization compared to Dendron's hierarchical system
- Fewer built-in features and extensions, requiring more manual setup
- Smaller community and ecosystem, potentially leading to slower development
Code Comparison
Foam (example of creating a new note):
const newNote = foam.create('My New Note');
foam.write(newNote, 'This is the content of my new note.');
Dendron (example of creating a new note):
const newNote = dendron.createNote({
name: 'my-new-note',
content: 'This is the content of my new note.',
schema: 'default'
});
Both Foam and Dendron are open-source note-taking and knowledge management tools built on top of Visual Studio Code. While Foam emphasizes simplicity and flexibility, Dendron offers a more structured approach with hierarchical organization and built-in features. The choice between the two depends on individual preferences for structure, customization, and available features.
A privacy-first, open-source platform for knowledge management and collaboration. Download link: http://github.com/logseq/logseq/releases. roadmap: http://trello.com/b/8txSM12G/roadmap
Pros of Logseq
- Built-in graph view for visualizing connections between notes
- Supports both Markdown and Org-mode syntax
- Offline-first approach with local-first data storage
Cons of Logseq
- Less structured hierarchy compared to Dendron's vault system
- Limited customization options for themes and plugins
- Steeper learning curve for users new to outliner-style note-taking
Code Comparison
Logseq (ClojureScript):
(defn get-block-by-uuid [uuid]
(when uuid
(db/entity [:block/uuid (uuid/uuid uuid)])))
Dendron (TypeScript):
export function getNoteByFname(fname: string): Note | null {
return engine.notes[fname] || null;
}
Both projects are open-source note-taking applications, but they differ in their approach and implementation. Logseq focuses on a graph-based, outliner-style system, while Dendron emphasizes hierarchical organization with its vault structure. Logseq's use of ClojureScript contrasts with Dendron's TypeScript codebase, reflecting different design philosophies and target audiences.
A privacy-first, self-hosted, fully open source personal knowledge management software, written in typescript and golang.
Pros of SiYuan
- Built-in web server for easy access across devices
- Supports real-time rendering of mathematical formulas
- Offers a block-based editor for flexible content organization
Cons of SiYuan
- Less extensive plugin ecosystem compared to Dendron
- Steeper learning curve for users new to block-based note-taking
- Limited integration with version control systems
Code Comparison
SiYuan (JavaScript):
export const openRecentDocs = () => {
fetchPost("/api/storage/getRecentDocs", {}, (response) => {
openFileById(response.data[0].id);
});
};
Dendron (TypeScript):
export async function openRecentDocs(): Promise<void> {
const recentDocs = await workspace.getRecentDocs();
if (recentDocs.length > 0) {
await workspace.openNote(recentDocs[0]);
}
}
Both code snippets demonstrate opening recent documents, but SiYuan uses a custom API call, while Dendron leverages the workspace object, reflecting their different architectures.
CLI and local web plain text note‑taking, bookmarking, and archiving with linking, tagging, filtering, search, Git versioning & syncing, Pandoc conversion, + more, in a single portable script.
Pros of nb
- Lightweight and command-line based, offering simplicity and speed
- Supports multiple file formats (Markdown, plain text, and others)
- Easy integration with existing shell workflows and scripts
Cons of nb
- Less feature-rich compared to Dendron's extensive knowledge management capabilities
- Limited visual interface, which may be less intuitive for some users
- Lacks advanced linking and hierarchical organization features
Code Comparison
nb:
nb add "New note content"
nb edit my-note
nb search "keyword"
Dendron:
import { Dendron } from "@dendronhq/dendron-api";
const dendron = new Dendron();
await dendron.init();
await dendron.note.create({ name: "new-note" });
Summary
nb is a lightweight, command-line based note-taking tool that excels in simplicity and integration with shell workflows. It supports multiple file formats and offers quick note creation and searching capabilities.
Dendron, on the other hand, is a more comprehensive knowledge management system with advanced features like hierarchical organization, powerful linking, and a visual interface. It's better suited for complex knowledge bases and larger projects.
The choice between nb and Dendron depends on the user's preference for simplicity versus advanced features, and whether they prefer a command-line or graphical interface for note-taking and knowledge management.
Build your personal knowledge base with Trilium Notes
Pros of Trilium
- Rich text editing with WYSIWYG support
- Built-in encryption for sensitive notes
- Flexible attribute system for advanced organization
Cons of Trilium
- Steeper learning curve due to more complex features
- Less integration with external tools and workflows
- Limited mobile support (only through web interface)
Code Comparison
Trilium (JavaScript):
const note = await becca.createNote(parentNote, 'New note', 'This is the content');
note.setLabel('myLabel', 'myValue');
await note.save();
Dendron (TypeScript):
const node = new DNode({
fname: 'new-note',
body: 'This is the content',
custom: { myLabel: 'myValue' }
});
await engine.write(node);
Both Dendron and Trilium are powerful note-taking applications with distinct features. Trilium offers a more traditional note-taking experience with rich text editing and built-in encryption, while Dendron focuses on a markdown-based, developer-friendly approach with strong version control integration. The code examples demonstrate the different approaches to note creation and metadata handling in each system.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Dendron
Dendron is an open-source, local-first, markdown-based, note-taking tool. It's a personal knowledge management solution (PKM) built specifically for developers and integrates natively with IDEs like VS Code and VSCodium.
Motivation
"We are overwhelmed with information and we don't have the tools to properly index and filter through it. [The development of these tools, which] will give society access to and command over the inherited knowledge of the ages [should] be the first objective of our scientist" - Vannevar Bush, 1945
Why
Most PKM tools help you create notes but slam into a wall retrieving them once your knowledge base reaches a certain size threshold. That threshold varies with the tool, but virtually everything stops working past 10k notes unless the user was extremely diligent about organizing their knowledge. Past this threshold, entropy wins and every query becomes a keyword search and scrolling through pages of results.
Dendron's mission is to help humans organize, find, and work with any amount of knowledge.
It not only helps you create notes but also retrieve them - retrieval works as well with ten notes as it does with ten thousand.
How
Dendron builds on top of the past five decades of programming languages and developer tooling. We apply the key lessons from software to the management of general knowledge. We make managing general knowledge like managing code and your PKM like an IDE.
Design Principles
Developer Centric
Dendron aims to create a world class developer experience for managing knowledge.
Our goal is to provide a tool with the efficiency of Vim, the extensibility of Emacs, and the approachability of VS Code.
What this means:
- dendron features are text centric and composables
- dendron provides the lowest friction interface for working with your knowledge base
- dendron optimizes for efficiency, speed, and keyboard focused ux
- dendron comes with sane defaults and the ability to customize to your liking
- dendron can be extended along any dimension
Gradual Structure
Dendron extends markdown with structural primitives to make it easier to manage at scale and tooling on top to work with this structure.
Different knowledge bases require different levels of structure - a PKM used for keeping daily journals is different than a company wide knowledge base used by thousands of developers.
Dendron works with any level of structure, meaning you can take free form notes when starting out and gradually layer on more structure as your knowledge base grows more.
Flexible and Consistent
Dendron is both flexible and consistent. It provides a consistent structure for all your notes and gives you the flexibility to change that structure.
In Dendron, you can refactor notes and Dendron will make sure that your PKM is consistent throughout. This means that you have the best of both worlds: a basic structure for the organization but the flexibility to change it.
Features
Dendron has hundreds of features. The following is a list of highlights.
It's just Plaintext
- manage using git
- use git blame to see individual edits
- edit in anything that works on text files (eg. Vim)
Markdown and More
- create diagrams using mermaid
- write math using katex
- embed notes (and parts of notes) in multiple places using note references
Lookup
- one unified way to find and create notes
- quickly traverse and create new hierarchies
Schema
- ensure consistency for your knowledge base
- get autocomplete hints when creating new notes
- automatically apply common templates to notes on creation
Navigation
- explore relationships using backlinks
- navigate to notes, headers and arbitrary blocks
- visualize your knowledge base using the graph view
Refactor
- restructure your knowledge base without breaking links
- rename a single note or refactor using arbitrary regex
- rename and move individual sections within notes
Vaults
- mix and match knowledge using vaults, a git backed folder for your notes
- use vaults to separate concerns, like personal notes and work notes
- publish vaults on git to collaborate and share knowledge with others
Publish
- export your knowledge base as a static (nextjs) site
- lookup locally and share globally with generated links
- manage what you publish using fine grained permissions on a per vault, per hierarchy and per note basis
Use Cases
- personal knowledge management (PKM)
- documentation
- meeting notes
- tasks and todos
- blogging
- customer relationship management
Getting Started
Interested in trying out Dendron? Jump right in with the Getting Started Guide!
Join Us
Dendron wouldn't be what it is today without our wonderful set of members and supporters.
Community Calendar
We have a bunch of community events that we host throughout the week. You can stay up to date on whats happening by taking a look at our community calendar!
- View and register for upcoming Dendron Community Events on Luma
Dendron Newsletter
Dendron sends out a weekly newsletter highlighting:
- Latest release features
- Latest Dendron blog posts
- Insights from the Dendron Discord community
- RFC updates and GitHub discussions
- and more!
Join other Dendrologists
There are a variety of ways to connect with Dendron devs, contributors, and other members of the Dendron community:
- Join the Dendron on Discord
- Follow Dendron on Twitter (
@dendronhq) - Checkout Dendron on GitHub
- Read the Dendron Blog
- Subscribe to the Dendron Newsletter
Contributors â¨
Dendron wouldn't be what it is today without help from the wonderful gardeners ð¨âð¾ð©âð¾
If you would like to contribute (docs, code, finance, or advocacy), you can find instructions to do so here. For setup of local development environment run ./setup.sh which automates the setup.
(emoji key):
This project follows the all-contributors specification. We welcome community contributions and pull requests. See the Dendron development guide for information on how to set up a development environment and submit code.
License
Dendron is distributed under the Apache License, Version 2.0.
Top Related Projects
A personal knowledge management and sharing system for VSCode
A privacy-first, open-source platform for knowledge management and collaboration. Download link: http://github.com/logseq/logseq/releases. roadmap: http://trello.com/b/8txSM12G/roadmap
A privacy-first, self-hosted, fully open source personal knowledge management software, written in typescript and golang.
CLI and local web plain text note‑taking, bookmarking, and archiving with linking, tagging, filtering, search, Git versioning & syncing, Pandoc conversion, + more, in a single portable script.
Build your personal knowledge base with Trilium Notes
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot