Pros of Trilium

• More active development and frequent updates
• Larger community and user base
• Better documentation and support resources

Cons of Trilium

• Potentially less stable due to frequent changes
• May have a steeper learning curve for new users
• Could be more resource-intensive due to additional features

Code Comparison

Trilium:

const Note = require('./note');
const NoteRevision = require('./note_revision');
const Branch = require('./branch');
const Attribute = require('./attribute');
const RecentNote = require('./recent_note');

TriliumNext/Trilium:

const Note = require('./note');
const NoteRevision = require('./note_revision');
const Branch = require('./branch');
const Attribute = require('./attribute');
const RecentNote = require('./recent_note');

The code comparison shows that both repositories have similar core structures and modules. This suggests that TriliumNext/Trilium may be a fork or alternative version of the main Trilium project. The similarities in code structure indicate that the fundamental architecture and design principles are likely shared between the two projects.

Given the limited information available about TriliumNext/Trilium, it's challenging to provide a more detailed comparison. The main Trilium project appears to be the primary and more actively maintained version, while TriliumNext/Trilium might be an experimental or alternative implementation with potentially different goals or features.

Pros of Logseq

• Open-source with a strong community-driven development approach
• Built-in support for graph visualization and bidirectional linking
• Offline-first architecture with local file storage

Cons of Logseq

• Less robust hierarchical note organization compared to Trilium
• Limited customization options for UI and theming
• Steeper learning curve for users new to outliner-style note-taking

Code Comparison

Logseq (ClojureScript):

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

Trilium (JavaScript):

function getNodeByKey(noteId) {
    return utils.getNoteOrThrow(noteId);
}

Both projects use different programming languages, reflecting their architectural choices. Logseq's ClojureScript code showcases its functional programming approach, while Trilium's JavaScript demonstrates its more traditional object-oriented style.

Logseq focuses on block-based note-taking with a flat structure, whereas Trilium emphasizes hierarchical organization. This fundamental difference is reflected in their respective codebases and user interfaces.

Pros of Obsidian

• User-friendly interface with a gentle learning curve
• Extensive plugin ecosystem for customization
• Strong community support and active development

Cons of Obsidian

• Closed-source, limiting user control and modification
• Lack of built-in synchronization (requires paid service or third-party solutions)

Code Comparison

While both Trilium and Obsidian use different technologies, a direct code comparison isn't particularly relevant. Trilium is open-source and written primarily in JavaScript, while Obsidian is closed-source and uses Electron and TypeScript.

Trilium (JavaScript):

const Note = require('../../entities/note');
const noteService = require('../../services/notes');
const utils = require('../../services/utils');

Obsidian (TypeScript, based on plugin API):

import { App, Plugin, PluginSettingTab, Setting } from 'obsidian';
export default class MyPlugin extends Plugin {
  onload() {
    // Plugin initialization
  }
}

Note that the Obsidian code example is based on its plugin API, as the core application code is not publicly available.

Pros of Foam

• Built as a VS Code extension, leveraging a familiar and powerful editor
• Supports publishing notes as a static website
• Highly customizable with VS Code's extensive plugin ecosystem

Cons of Foam

• Steeper learning curve for users not familiar with VS Code
• Less integrated experience compared to Trilium's all-in-one solution
• Limited mobile support, primarily desktop-focused

Code Comparison

Foam (JavaScript):

export async function createNoteFromTemplate(
  templatePath: string,
  notePath: string,
  substitutions: { [key: string]: string } = {}
): Promise<Uri> {
  // ... implementation
}

Trilium (JavaScript):

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

Both projects use JavaScript/TypeScript, but Foam's code is more focused on VS Code integration, while Trilium's code is part of a standalone application. Foam's approach allows for deeper integration with VS Code features, while Trilium offers a more self-contained note-taking experience.

Pros of Dendron

• Built on VSCode, leveraging its powerful ecosystem and extensions
• Supports publishing notes as a static website
• Hierarchical note organization with flexible schemas

Cons of Dendron

• Steeper learning curve due to VSCode integration and schema concepts
• Less intuitive for users who prefer a standalone application
• Limited built-in visualization options compared to Trilium

Code Comparison

Dendron (JavaScript):

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

Trilium (JavaScript):

function createNoteLink(noteId, noteTitle) {
    return `[${noteTitle}](#root/${noteId})`;
}

Both projects use JavaScript, but Dendron's code shows TypeScript usage and a more complex link structure, while Trilium's approach is simpler and uses a different link format.

Dendron focuses on hierarchical note organization and integrates with VSCode, making it powerful but potentially more complex for some users. Trilium offers a standalone application with rich visualization features, which may be more intuitive for users seeking a dedicated note-taking tool. The choice between them depends on individual preferences for development environment, note organization, and desired features.

Pros of Standard Notes

• Cross-platform synchronization with end-to-end encryption
• Simple, clean interface focused on privacy and security
• Extensive plugin system for customization and extended functionality

Cons of Standard Notes

• Less robust organizational features compared to Trilium's hierarchical structure
• Limited offline functionality, especially on mobile devices
• Steeper learning curve for advanced features and customization

Code Comparison

Standard Notes (JavaScript):

export function generateUUID() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}

Trilium (JavaScript):

function generateEntityId() {
    return utils.randomString(12);
}

Both projects use JavaScript for their core functionality. Standard Notes employs a more complex UUID generation method, while Trilium opts for a simpler random string approach. This reflects the overall design philosophy of each project, with Standard Notes focusing on robust, standardized methods and Trilium prioritizing simplicity and efficiency.