Pros of Standard Notes

• Stronger focus on privacy and end-to-end encryption
• Cleaner, more minimalist user interface
• Cross-platform synchronization with a self-hosted option

Cons of Standard Notes

• Fewer advanced features compared to Joplin (e.g., no web clipper)
• Limited markdown support in the free version
• Smaller community and fewer third-party extensions

Code Comparison

Standard Notes (TypeScript):

export function encryptNoteContent(content: string, key: string): string {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  let encrypted = cipher.update(content, 'utf8', 'base64');
  encrypted += cipher.final('base64');
  return iv.toString('hex') + ':' + encrypted;
}

Joplin (JavaScript):

async function encryptString(plainText, key) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
  let encrypted = cipher.update(plainText, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  const tag = cipher.getAuthTag().toString('hex');
  return iv.toString('hex') + encrypted + tag;
}

Both projects implement note encryption, but Standard Notes uses AES-256-CBC while Joplin uses AES-256-GCM. Joplin's implementation includes an authentication tag for added security.

Pros of Logseq

• Built-in graph view for visualizing connections between notes
• Supports bidirectional linking and block-level referencing
• Offers a local-first approach with optional sync to various cloud services

Cons of Logseq

• Steeper learning curve due to its unique structure and features
• Less robust mobile app support compared to Joplin
• Limited export options and formatting capabilities

Code Comparison

Logseq (ClojureScript):

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

Joplin (JavaScript):

async function loadNoteByUuid(uuid) {
  return await Note.loadByUuid(uuid);
}

Key Differences

• Logseq uses a graph-based structure, while Joplin follows a more traditional hierarchical note organization
• Logseq focuses on networked thought and knowledge management, whereas Joplin emphasizes note-taking and task management
• Joplin offers end-to-end encryption for synced data, while Logseq relies on third-party sync solutions

User Base

• Logseq appeals to users who prefer a non-linear, interconnected approach to note-taking
• Joplin attracts users looking for a more familiar, feature-rich note-taking application with strong privacy features

Both projects are open-source and actively maintained, with growing communities and regular updates.

Pros of Notable

• Simpler, more minimalist interface focused on note-taking
• Faster performance, especially with large numbers of notes
• Native support for KaTeX math equations

Cons of Notable

• Fewer features and integrations compared to Joplin
• Less active development and smaller community
• No built-in synchronization options

Code Comparison

Notable (JavaScript):

export function getNotes(notePaths, opts = {}) {
  return Promise.all(
    notePaths.map(notePath => Note.read(notePath, opts))
  );
}

Joplin (TypeScript):

export async function getNotes(query: string, options: any = null): Promise<Note[]> {
  const notes = await Note.previews(query, options);
  return Note.sortNotes(notes, options.order);
}

Both projects use JavaScript/TypeScript for their core functionality. Notable's code tends to be more concise, while Joplin's is more feature-rich and type-safe due to TypeScript usage.

Notable focuses on a straightforward note-taking experience with a clean interface, making it ideal for users who prefer simplicity. However, it lacks some advanced features and synchronization options that Joplin offers.

Joplin provides a more comprehensive solution with robust synchronization, plugins, and a larger feature set. It has a more active development community but may feel more complex for users seeking a minimalist approach.

Choose Notable for a streamlined note-taking experience or Joplin for a feature-rich, highly customizable solution with strong synchronization capabilities.

Pros of zk

• Lightweight and focused on plain text note-taking
• Command-line interface for efficient workflow
• Designed for Zettelkasten method and linking notes

Cons of zk

• Limited features compared to Joplin's rich functionality
• No built-in synchronization or cloud storage options
• Less user-friendly for those who prefer graphical interfaces

Code Comparison

zk uses a simple plain text format for notes:

# Note Title

Content of the note

#tag1 #tag2

Joplin uses a more structured format with metadata:

{
  "title": "Note Title",
  "body": "Content of the note",
  "created_time": 1234567890,
  "updated_time": 1234567891,
  "tags": ["tag1", "tag2"]
}

Summary

zk is a minimalist, command-line tool focused on the Zettelkasten method, while Joplin is a feature-rich, cross-platform note-taking application with synchronization capabilities. zk appeals to users who prefer plain text and command-line interfaces, whereas Joplin caters to those seeking a more comprehensive note-taking solution with graphical interfaces and advanced features.