Pros of Logseq

• More mature and stable project with a larger user base
• Offers both local-first and cloud sync options
• Supports multiple export formats (Markdown, EDN, JSON)

Cons of Logseq

• Less focus on real-time collaboration features
• UI can be less intuitive for new users
• Slower development of advanced graph visualization features

Code Comparison

Logseq (ClojureScript):

(defn parse-property [line]
  (when-let [[_ k v] (re-find #"^([^:]+)::(.+)$" (string/trim line))]
    [(string/trim k) (string/trim v)]))

Athens (ClojureScript):

(defn parse-block [s]
  (let [trimmed (string/trim s)]
    (if-let [[_ indent content] (re-matches #"(\s*)(.+)" trimmed)]
      {:indent (count indent) :content content}
      {:indent 0 :content trimmed})))

Both projects use ClojureScript and share similar parsing approaches for their note-taking functionalities. However, Logseq's codebase is more extensive and mature, reflecting its longer development history and broader feature set. Athens focuses more on graph-based knowledge management and real-time collaboration, which is evident in its codebase structure and core functions.

Pros of Dendron

• More mature project with a larger community and ecosystem
• Hierarchical note structure for better organization
• Extensive documentation and tutorials available

Cons of Dendron

• Steeper learning curve due to more complex features
• Requires VS Code as the primary editor
• Less focus on real-time collaboration

Code Comparison

Dendron (TypeScript):

export function createNoteLink(note: Note, alias?: string): string {
  const fname = note.fname;
  return alias ? `[[${fname}|${alias}]]` : `[[${fname}]]`;
}

Athens (ClojureScript):

(defn create-block-link
  [block-uid & {:keys [alias]}]
  (let [link (str "[[" block-uid "]]")]
    (if alias
      (str link "[" alias "]")
      link)))

Both projects use different languages but implement similar functionality for creating note/block links. Dendron's approach is more TypeScript-oriented, while Athens uses a functional ClojureScript style.

Athens focuses on a graph-based structure and real-time collaboration, making it more suitable for networked thought and team workflows. Dendron excels in personal knowledge management with its hierarchical structure and powerful search capabilities.

Choose Athens for a more visual, collaborative experience, or Dendron for a structured, individual note-taking approach integrated with VS Code.

Pros of Foam

• Lightweight and flexible, integrating seamlessly with VS Code
• Extensive customization options through VS Code extensions
• Active community with frequent updates and contributions

Cons of Foam

• Steeper learning curve for users unfamiliar with VS Code
• Less polished user interface compared to Athens
• Limited built-in features, relying heavily on external extensions

Code Comparison

Athens (ClojureScript):

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

Foam (TypeScript):

export function createNote(title: string): Note {
  return {
    id: generateId(),
    title,
    content: '',
    links: [],
  };
}

Both projects aim to provide networked thought tools, but they differ in their approach. Athens offers a more integrated, standalone solution with a focus on graph visualization and real-time collaboration. Foam, on the other hand, leverages the power of VS Code to provide a flexible, extensible platform for personal knowledge management. The choice between the two depends on individual preferences for user interface, extensibility, and integration with existing workflows.

Pros of SiYuan

• More active development with frequent updates and releases
• Built-in features for task management and kanban boards
• Supports multiple languages and has a larger international user base

Cons of SiYuan

• Less focus on networked thought and graph visualization
• Closed-source backend, limiting community contributions and customization
• Steeper learning curve due to more complex features and interface

Code Comparison

SiYuan (Go):

func (box *Box) Index(ctx context.Context) (err error) {
    box.indexLock.Lock()
    defer box.indexLock.Unlock()
    if !box.Exist() {
        return errors.New("box not exist")
    }
    return box.index(ctx)
}

Athens (Clojure):

(defn parse-block
  [block]
  (let [content (:block/string block)
        children (:block/_parent block)]
    (merge
     (parse-content content)
     {:block/children (mapv parse-block children)})))

Both projects use different programming languages, reflecting their architectural choices. SiYuan's Go code focuses on indexing and file management, while Athens' Clojure code emphasizes parsing and structuring block content. This difference highlights SiYuan's emphasis on file organization and Athens' focus on networked thought.