siyuan

Pros of Logseq

• Open-source with a strong community-driven development approach
• Built-in graph view for visualizing connections between notes
• Supports both Markdown and Org-mode syntax

Cons of Logseq

• Less polished user interface compared to SiYuan
• Limited customization options for themes and appearance
• Slower performance with large databases

Code Comparison

Logseq (ClojureScript):

(defn get-block-by-uuid [uuid]
  (when uuid
    (db/entity [:block/uuid (uuid/uuid uuid)])))

SiYuan (Go):

func (tx *Transaction) GetBlockByID(id string) (*Block, error) {
    block := &Block{ID: id}
    err := tx.queryBlock(block)
    return block, err
}

Both projects use different programming languages, reflecting their architectural choices. Logseq's ClojureScript code emphasizes functional programming, while SiYuan's Go code follows a more traditional object-oriented approach. The code snippets demonstrate similar functionality for retrieving blocks or notes by their unique identifiers, showcasing the core data management capabilities of both applications.

Pros of Obsidian-releases

• More established and widely adopted in the note-taking community
• Extensive plugin ecosystem with a large number of community-contributed extensions
• Cross-platform support including mobile apps for iOS and Android

Cons of Obsidian-releases

• Closed-source core, limiting community contributions to the main application
• Sync and publish features require paid subscriptions
• Less integrated knowledge graph visualization compared to SiYuan

Code Comparison

While both projects are primarily focused on note-taking and knowledge management, their codebases differ significantly. Obsidian is built with Electron and TypeScript, while SiYuan uses Go for its backend and TypeScript for the frontend.

SiYuan (Go backend example):

func (tx *Transaction) doInsertBlock(operation *Operation) (err error) {
    block := operation.Data.(map[string]interface{})
    tree, err := tx.loadTree(block["rootID"].(string))
    if nil != err {
        return
    }
    node := treenode.NewNodeFromJSON(block)
    // ... (additional logic)
}

Obsidian (TypeScript frontend example):

export class Vault {
  getFiles(): TFile[] {
    return Object.values(this.fileMap);
  }

  getMarkdownFiles(): TFile[] {
    return this.getFiles().filter((file) => file.extension === "md");
  }
}

Note: As Obsidian's core is closed-source, the code example is based on publicly available API documentation and may not reflect the actual internal implementation.

Pros of Foam

• Open-source and highly customizable, allowing users to extend functionality
• Integrates seamlessly with Visual Studio Code, leveraging its powerful features
• Supports local storage and version control through Git

Cons of Foam

• Steeper learning curve, especially for users unfamiliar with VS Code
• Less polished user interface compared to SiYuan's native app
• Limited mobile support and sync capabilities

Code Comparison

Foam (JavaScript):

const generateNoteFromTemplate = async (templatePath, targetPath, variables) => {
  const templateContent = await fs.readFile(templatePath, 'utf8');
  const renderedContent = renderTemplate(templateContent, variables);
  await fs.writeFile(targetPath, renderedContent);
};

SiYuan (Go):

func (box *Box) CreateDocWithMd(boxID, parentID, name, markdown string) (string, error) {
    id := ast.NewNodeID()
    path := filepath.Join(box.Path, id+".sy")
    if err := os.WriteFile(path, []byte(markdown), 0644); err != nil {
        return "", err
    }
    return id, nil
}

Both projects aim to provide note-taking and knowledge management solutions, but they differ in their approach and target audience. Foam is more flexible and developer-friendly, while SiYuan offers a more polished, out-of-the-box experience with advanced features like block-level references and bi-directional linking.

Pros of Dendron

• Open-source and highly extensible through VS Code ecosystem
• Powerful hierarchical note-taking with flexible schemas
• Strong focus on knowledge management and linking related concepts

Cons of Dendron

• Steeper learning curve due to complex features and CLI usage
• Less intuitive for users seeking a simple, visual note-taking experience
• Requires separate setup and configuration of VS Code

Code Comparison

Dendron (TypeScript):

export class DendronEngine {
  constructor(private vault: Vault) {}
  async createNote(note: NoteProps): Promise<Note> {
    // Note creation logic
  }
}

SiYuan (Go):

type Notebook struct {
    ID   string `json:"id"`
    Name string `json:"name"`
}

func (n *Notebook) CreateNote(title string) (*Note, error) {
    // Note creation logic
}

Both projects use different programming languages, reflecting their architectural choices. Dendron leverages TypeScript for its VS Code integration, while SiYuan uses Go for its standalone application approach.

Pros of Athens

• Open-source and built with Clojure, promoting transparency and extensibility
• Focuses on networked thought and bi-directional linking
• Emphasizes community-driven development and collaboration

Cons of Athens

• Less mature and feature-rich compared to SiYuan
• Smaller user base and community support
• Limited mobile support and offline capabilities

Code Comparison

Athens (Clojure):

(defn create-page [title]
  (let [block-uid (gen-block-uid)]
    (d/transact! conn [{:block/uid block-uid
                        :node/title title
                        :block/children []}])))

SiYuan (Go):

func CreateDocWithMd(boxID, parentID, markdown string) (string, error) {
    id := ast.NewNodeID()
    tree, err := parseKTree(markdown)
    if nil != err {
        return "", err
    }
    return createDoc(boxID, parentID, id, tree)
}

Both projects aim to provide note-taking and knowledge management solutions, but they differ in their approach and implementation. Athens focuses on networked thought and community-driven development, while SiYuan offers a more comprehensive feature set and better cross-platform support. The code snippets showcase the different programming languages used (Clojure for Athens, Go for SiYuan) and their respective approaches to creating new pages or documents.

Pros of nb

• Lightweight and command-line based, ideal for users comfortable with terminal interfaces
• Focuses on simplicity and speed for note-taking and management
• Easily integrates with existing command-line workflows and tools

Cons of nb

• Limited graphical user interface, which may be less intuitive for some users
• Fewer advanced features compared to SiYuan, such as mind mapping or extensive customization options
• May require more technical knowledge to set up and use effectively

Code Comparison

nb:

nb add "My new note"
nb edit 1
nb search "keyword"

SiYuan:

editor.insertText("My new note");
editor.updateBlock(blockId, content);
editor.search("keyword");

The code comparison shows the difference in approach between nb's command-line interface and SiYuan's JavaScript API for similar note-taking operations. nb uses simple shell commands, while SiYuan provides a more programmatic interface for interacting with notes and the editor.