obsidian-releases

Pros of Logseq

• Open-source and fully free, encouraging community contributions
• Built-in graph view for visualizing connections between notes
• Supports both Markdown and Org-mode syntax

Cons of Logseq

• Steeper learning curve due to its outliner-based structure
• Less extensive plugin ecosystem compared to Obsidian
• Limited customization options for the user interface

Code Comparison

Logseq (ClojureScript):

(defn get-block-content
  [block]
  (when (map? block)
    (:content block)))

Obsidian (TypeScript):

export function getBlockContent(block: TFile): string | null {
  if (block instanceof TFile) {
    return block.content;
  }
  return null;
}

Both projects use different programming languages, reflecting their distinct architectures. Logseq is built with ClojureScript, emphasizing functional programming, while Obsidian uses TypeScript, providing strong typing for JavaScript. The code snippets demonstrate basic operations for retrieving block content, showcasing the syntactical differences between the two languages.

Pros of Foam

• Open-source and fully customizable
• Integrated with Visual Studio Code for a familiar development environment
• Supports multiple knowledge graph visualization options

Cons of Foam

• Less polished user interface compared to Obsidian
• Smaller community and plugin ecosystem
• Steeper learning curve for non-developers

Code Comparison

Foam (JavaScript):

const graph = new Graph();
graph.addNode('concept1');
graph.addNode('concept2');
graph.addEdge('concept1', 'concept2');

Obsidian (JavaScript):

app.workspace.activeLeaf.openFile(app.metadataCache.getFirstLinkpathDest('concept1', ''));
app.workspace.activeLeaf.openFile(app.metadataCache.getFirstLinkpathDest('concept2', ''));

Both projects use JavaScript, but Foam's code is more focused on graph manipulation, while Obsidian's API is geared towards file operations and workspace management. Foam's approach allows for more flexibility in creating custom knowledge structures, while Obsidian provides a more streamlined experience for typical note-taking workflows.

Pros of Dendron

• Open-source and highly extensible, allowing for community contributions and customizations
• Hierarchical note-taking system with powerful refactoring and navigation features
• Built-in version control and publishing capabilities

Cons of Dendron

• Steeper learning curve due to its hierarchical structure and advanced features
• Requires VS Code as the primary editor, which may not appeal to all users
• Smaller community and ecosystem compared to Obsidian

Code Comparison

Dendron (schema.yml):

version: 1
schemas:
  - id: root
    children:
      - projects
      - areas
      - resources

Obsidian (no equivalent file, uses folder structure):

.
├── Projects/
├── Areas/
└── Resources/

Summary

Dendron offers a more structured and hierarchical approach to note-taking, with built-in version control and publishing features. It's highly extensible but requires VS Code and has a steeper learning curve. Obsidian, on the other hand, provides a more flexible and user-friendly experience with a larger community and plugin ecosystem. The choice between the two depends on personal preferences and specific note-taking needs.

Pros of zk

• Command-line interface for efficient note-taking and management
• Lightweight and fast, suitable for users who prefer terminal-based workflows
• Flexible and customizable with support for various text editors

Cons of zk

• Steeper learning curve for users not familiar with command-line tools
• Less visual and interactive compared to graphical note-taking applications
• Smaller community and ecosystem of plugins/extensions

Code Comparison

zk:

zk new "My new note"
zk list --tag important
zk edit <note-id>

Obsidian:

// No direct code comparison available
// Obsidian uses a graphical interface
// and plugin system for functionality

Summary

zk is a command-line tool for note management, offering speed and flexibility for terminal-savvy users. Obsidian, on the other hand, provides a graphical interface with a rich ecosystem of plugins and visual features. While zk excels in efficiency and customization through text-based workflows, Obsidian offers a more user-friendly experience with visual linking and graphing capabilities. The choice between the two depends on personal preferences for command-line vs. graphical interfaces and the desired level of visual representation for notes and connections.

Pros of SiYuan

• Built-in sync and backup functionality
• Supports block-level references and bidirectional links
• Offers a web-based interface for easy access across devices

Cons of SiYuan

• Less extensive plugin ecosystem compared to Obsidian
• Steeper learning curve for some users
• Limited customization options for themes and appearance

Code Comparison

SiYuan (SQL-like query language):

SELECT * FROM blocks WHERE content LIKE '%example%'

Obsidian (JavaScript-based search):

app.workspace.getActiveFile().content.contains('example')

Summary

SiYuan and Obsidian are both powerful note-taking applications with distinct features. SiYuan offers built-in sync and a web-based interface, making it convenient for cross-device usage. It also provides block-level references and bidirectional links, enhancing note organization.

However, SiYuan has a smaller plugin ecosystem and may have a steeper learning curve for some users. It also offers fewer customization options compared to Obsidian.

Obsidian, on the other hand, boasts a large and active community, resulting in an extensive plugin ecosystem and more customization possibilities. It uses a simpler Markdown format, which may be more familiar to some users.

The code comparison shows that SiYuan uses an SQL-like query language for searching, while Obsidian relies on JavaScript-based methods. This difference reflects the underlying architecture and approach of each application.

Pros of Athens

• Open-source and self-hostable, allowing for greater customization and control
• Built with Clojure, offering potential performance benefits for complex operations
• Focuses on networked thought and knowledge graphs, enhancing interconnected note-taking

Cons of Athens

• Smaller community and ecosystem compared to Obsidian
• Less mature and fewer features than Obsidian, which has been in development longer
• Steeper learning curve due to its unique approach and less documentation

Code Comparison

Athens (ClojureScript):

(defn create-page [title]
  (let [new-page {:title title :content ""}]
    (db/transact! [new-page])))

Obsidian (JavaScript/TypeScript):

app.vault.create(title + ".md", "").then((file) => {
  app.workspace.activeLeaf.openFile(file);
});

Both examples demonstrate creating a new page/note, but Athens uses a database transaction approach, while Obsidian interacts directly with the file system.