Pros of promnesia

• More flexible data sources, including local files and custom importers
• Supports advanced querying and filtering of browsing history
• Integrates well with other tools and workflows (e.g., org-mode, Anki)

Cons of promnesia

• Steeper learning curve and more complex setup
• Less polished user interface compared to Memex
• Smaller community and fewer out-of-the-box features

Code comparison

promnesia:

from promnesia.sources import auto

def index():
    yield from auto.index()

Memex:

import { createAnnotation } from '@worldbrain/memex-common/annotations'

const annotation = createAnnotation({
    url: 'https://example.com',
    body: 'This is a note',
})

Key differences

1. Language: promnesia is primarily written in Python, while Memex uses JavaScript/TypeScript
2. Architecture: promnesia focuses on indexing and querying, Memex on annotation and organization
3. Target audience: promnesia caters to power users and developers, Memex aims for a broader user base
4. Integration: promnesia offers more flexibility for custom integrations, Memex provides a more cohesive ecosystem
5. User interface: Memex has a more polished UI, promnesia relies more on command-line and browser extension

Pros of Trilium

• More comprehensive note-taking features, including hierarchical organization and rich text editing
• Self-hosted solution, offering greater privacy and data control
• Supports multiple data formats and file attachments

Cons of Trilium

• Steeper learning curve due to more complex features
• Requires setup and maintenance of a self-hosted instance
• Less focus on web content saving and annotation compared to Memex

Code Comparison

Trilium (JavaScript):

const Note = require('./note');
const NoteRevision = require('./note_revision');

async function createNote(parentNoteId, title, content) {
    const note = new Note(parentNoteId, title, content);
    await note.save();
}

Memex (TypeScript):

import { Page } from './types'
import { createPageDoc } from './storage'

async function savePage(page: Page) {
    const pageDoc = await createPageDoc(page)
    return pageDoc
}

Both projects use JavaScript/TypeScript, but Trilium's codebase is more focused on note management, while Memex emphasizes web page saving and indexing.

Pros of Logseq

• Open-source, offline-first personal knowledge management tool
• Supports bidirectional linking and graph visualization
• Flexible data format (Markdown/Org-mode) and extensible plugin system

Cons of Logseq

• Steeper learning curve for users new to networked thought tools
• Limited web clipping and annotation features compared to Memex
• Less focus on web research and content organization

Code Comparison

Logseq (ClojureScript):

(defn page-property [page-name property-name]
  (let [page (db/entity [:block/name page-name])
        properties (:block/properties page)]
    (get properties property-name)))

Memex (TypeScript):

export async function getPageMetadata(url: string): Promise<PageMetadata> {
  const { content } = await fetchPageContent(url)
  return extractMetadata(content)
}

While both projects are related to knowledge management, Logseq focuses on personal note-taking and organization, whereas Memex specializes in web research and content curation. Logseq offers a more comprehensive system for interconnected notes, while Memex excels in web page annotation and archiving. The code snippets reflect their different focuses, with Logseq handling internal data structures and Memex dealing with web page processing.

Pros of Obsidian

• Focused on local-first note-taking and knowledge management
• Extensive plugin ecosystem for customization
• Supports linking between notes and graph visualization

Cons of Obsidian

• Limited web browsing and bookmarking capabilities
• Less emphasis on collaborative features
• Steeper learning curve for advanced features

Code Comparison

Memex (JavaScript):

export async function savePageToStorage(page) {
  const { url, content, timestamp } = page
  await storage.set(url, { content, timestamp })
}

Obsidian (TypeScript):

export async function createNote(content: string, path: string) {
  const file = await vault.create(path, content)
  return file
}

Key Differences

Memex is primarily a browser extension for web research and bookmarking, while Obsidian is a desktop application for note-taking and personal knowledge management. Memex focuses on capturing and organizing web content, whereas Obsidian emphasizes creating and linking personal notes.

Memex offers features like full-text search of visited web pages and collaborative spaces, while Obsidian provides a more flexible note-taking environment with support for custom plugins and themes.

In terms of development, Memex uses JavaScript and is built as a browser extension, while Obsidian is developed in TypeScript and uses Electron for its desktop application.

Pros of Foam

• More flexible and customizable, allowing users to choose their preferred text editor
• Better integration with existing note-taking workflows and tools like Obsidian
• Supports local file storage, providing better privacy and data ownership

Cons of Foam

• Steeper learning curve, especially for users new to VS Code or Markdown
• Less polished user interface compared to Memex's browser extension
• Requires more manual setup and configuration

Code Comparison

Foam (TypeScript):

export interface IFoamWorkspace {
  get(uri: URI): Promise<Note | null>;
  list(): Promise<Note[]>;
  resolveLink(reference: string, baseUri?: URI): Promise<URI | null>;
}

Memex (JavaScript):

class PageIndexingBackground {
  async storeVisit(visit) {
    await this._pageStorage.addVisit(visit)
    await this._visitStorage.addVisit(visit)
  }
}

While both projects aim to enhance personal knowledge management, they take different approaches. Foam focuses on local file-based note-taking with extensive customization options, while Memex provides a more streamlined browser-based experience for web research and bookmarking. The code snippets reflect these differences, with Foam's interface emphasizing note management and linking, and Memex's class handling web page visits and storage.

Pros of Athens

• Open-source knowledge graph with bidirectional linking, offering a more structured approach to note-taking and knowledge management
• Built with Clojure and ClojureScript, providing a robust and functional programming foundation
• Supports local-first architecture, ensuring data privacy and offline functionality

Cons of Athens

• Less focus on web browsing and content capture compared to Memex
• Steeper learning curve due to its graph-based structure and unique interface
• Currently lacks mobile applications, limiting accessibility across devices

Code Comparison

Athens (ClojureScript):

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

Memex (JavaScript):

export function createPage(title) {
  return {
    id: generateUUID(),
    title,
    content: '',
    createdAt: Date.now(),
  }
}

Both projects use different languages and approaches, with Athens focusing on graph-based data structures and Memex on traditional web technologies. Athens' code reflects its emphasis on block-based note-taking, while Memex's code is geared towards web content management.