This repository is a local-first, source-cited knowledge base management system, delivered primarily as a Claude Code plugin and a standalone Python CLI tool. It manages Obsidian vaults with a strong emphasis on data integrity, provenance tracking, and deterministic operations. The architecture is a monolithic Python library (`claude_obsidian/`) with a formal transaction system for all vault mutations, a robust lint engine, and a retrieval pipeline (BM25 + optional semantic reranking). It features a sophisticated skill/agent framework for AI integration across multiple hosts (Claude, Cursor, Windsurf, etc.). While primarily an application, it incorporates significant data engineering and research data management (RDM) patterns. The provenance ledger system (`ledgers.py`) enforces strict schemas for sources and claims, including canonical URL handling, content-addressed identity, and evidence validation rules. The retrieval pipeline implements Anthropic's Contextual Retrieval pattern. This hybrid nature makes it a powerful tool for both knowledge management and structured research workflows. The codebase demonstrates exceptionally high craftsmanship in its transaction system, defensive I/O, and deterministic analysis tools. It is actively maintained with a comprehensive test suite and a formal release process. Its primary limitation is platform dependency on Linux/macOS for write operations (WSL required for Windows).
Memos is a self-hosted, full-stack memo/note-taking application with a Go backend and React/TypeScript frontend. It provides rich features including markdown editing with inline images and math, attachment management (images, video, audio, motion photos), spaces for collaboration, calendar and map views, AI-powered audio transcription, webhooks, SSO/OAuth2 identity providers, and a CEL-based filter engine for advanced querying. The architecture is layered with enforced import rules: internal utilities, provider interfaces (AI, storage, IDP), core business logic, a store layer with driver abstraction supporting SQLite, MySQL, and PostgreSQL, and a server layer exposing ConnectRPC/gRPC and HTTP APIs. The frontend uses CodeMirror 6 for the editor, TanStack Query for data fetching, and extensive custom hooks and UI primitives. The codebase is well-tested with unit, integration, and benchmark tests across both backend and frontend. Notable engineering highlights include a custom Common Expression Language (CEL) engine that compiles user-defined filters to SQL, a sliding window rate limiter, a thread-safe in-memory cache with TTL, and a protocol abstraction layer that transparently handles gRPC and ConnectRPC headers.
Logseq is a privacy-first, open-source knowledge management platform built as a monorepo containing an Electron desktop app, Capacitor-based mobile apps (iOS/Android), a web app, and a Node.js db-sync server. The codebase is predominantly ClojureScript (CLJS) with React/Rum for the UI, DataScript for the in-memory graph database, and SQLite (via better-sqlite3 and sqlite-wasm) for persistence. It uses shadow-cljs for CLJS compilation, webpack for JS bundling, and Tailwind CSS for styling. A separate OCaml-based CLI (logseq-cli) built with Melange provides graph inspection, sync, and CRUD operations against the same db-worker-node backend. The architecture separates concerns into deps/ subprojects (db, outliner, graph-parser, db-sync, common, publishing, shui) that are compiled as separate shadow-cljs targets and shared across Electron, browser, mobile, and CLI runtimes. The system has two graph types: file-based graphs (Markdown/Org) and DB graphs (SQLite-backed with DataScript in-memory querying). DB graphs enable real-time collaboration (RTC) via a Cloudflare Worker-based sync server (deps/db-sync) using WebSockets and D1 SQLite. The db-worker-node is a long-lived Node.js process that manages SQLite connections and sync state, communicating with the UI via a thread-api IPC mechanism. The outliner module handles block tree operations with structural invariants, while the graph-parser handles Markdown/Org parsing via mldoc. The publishing module generates static HTML sites from graphs. Key architectural patterns include: missionary for reactive async flows, promesa for promise composition, malli for schema validation, datascript for Datalog queries, and a component-based UI with Rum/React. The codebase has extensive test coverage via cljs.test, Playwright E2E tests (clj-e2e), and Python-based CLI E2E tests (cli-e2e). The repository is actively maintained with recent commits, 43k+ stars, and active issue triage, though the large monorepo complexity and multi-language surface (CLJS, OCaml, Swift, Kotlin, Python, JS) create maintenance challenges.
nb is a command-line note-taking, bookmarking, and archiving tool with Git-backed versioning, encryption, full-text search, tagging, pinning, and a built-in web server for browsing. It is implemented primarily as a single portable Bash script, with optional Go, Ksh, and Zsh wrappers. The architecture is a monolith CLI with a plugin system for extending subcommands and themes. Key entry points are the `nb` script and its aliases `bin/notes` and `bin/bookmark`. Data flows involve creating/editing notes in `NB_DIR`, where each notebook is a Git repository; operations create automatic commits, and an `.index` file per folder maintains ordering. The tool supports multiple notebooks, nested folders, encryption (OpenSSL/GPG), bookmark import from browsers, and remote sync via Git. The extensive test suite (2200+ BATS tests) covers all major features and edge cases.
Eleventy Notes is a highly opinionated static site generator template built on top of Eleventy (11ty). It is designed for publishing personal notes, documentation, wikis, or blogs with a focus on rich interlinking, client-side search, and customization. The system is a static site generator that processes Markdown files into a fully featured website. It includes a modular architecture with core infrastructure (layout, header, sidebar), and modules for wikilinks, callouts (admonitions), tags, custom properties, dynamic content queries, table of contents, search (using Pagefind), bookmarks, theming, translations, and page navigation. The build process uses Parcel for CSS/JS bundling and Eleventy for HTML generation. The application is designed to be configured via a single JavaScript file (`app.mjs`) and a SCSS file (`app.scss`). The code is well-structured, uses ES modules, and demonstrates advanced patterns such as custom markdown-it plugins, a generic query engine, and a tree generator. It is a template intended for end users to fork and customize, but the underlying codebase itself exhibits high craftsmanship and could serve as a reference for building Eleventy-based projects.
SiYuan is a privacy-first, local-first personal knowledge management system with a block-based WYSIWYG editor, AI assistant integration, cloud sync, and a plugin ecosystem. It is architected as a Go kernel (Gin HTTP API + WebSocket) paired with a TypeScript/Electron frontend, supporting desktop (Windows, macOS, Linux), mobile (Android, iOS, HarmonyOS), and browser/Docker deployment. The kernel handles all data operations: block tree persistence as JSON `.sy` files, SQLite indexing with FTS5 and SQLCipher encryption, attribute-view databases (tables, galleries, kanban), backlink resolution, full-text search, and sync via multiple providers (SiYuan cloud, S3, WebDAV, LAN). The frontend provides a rich editing experience with Markdown, LaTeX, Mermaid, mind maps, PDF annotation, flashcards (FSRS), and an agent chat interface. External dependencies include the Lute Markdown parser, dejavu sync library, Pandoc for document conversion, and PDF.js for PDF rendering. The system exposes a comprehensive REST API with contract-based validation and auto-generated TypeScript types, enabling third-party integrations and a community marketplace for plugins, themes, and templates.
Open Notebook is a self-hosted, AI-powered research assistant and knowledge management application. It allows users to collect sources (web pages, uploaded documents, text snippets), extract structured insights via LLM-driven transformations, organize content into notebooks, perform hybrid text/vector search, and generate AI podcasts with multi-speaker support using TTS models. The backend is built on Python with FastAPI and LangGraph for orchestration, SurrealDB for persistence (with a custom migration system), and the Esperanto library for multi-provider AI integration (OpenAI, Anthropic, Google, Ollama, and many others). The frontend is a modern Next.js application with React Query, i18n support for 14 locales, and a component library based on Radix UI/shadcn. The architecture follows a monolith-with-background-workers pattern: the FastAPI process handles both synchronous API requests and, via the surreal-commands library, asynchronous background jobs for content processing, embedding generation, and podcast generation. The codebase is well-structured with clear separation between API routers, domain models, utility modules, and frontend components. It exhibits strong security awareness—includes SSRF protection via DNS pinning, path containment for file uploads, Fernet encryption for stored credentials, and input validation throughout. The test suite is extensive (>100 test files) covering API endpoints, domain logic, error handling, and edge cases. There are some maintenance risks related to tight coupling with SurrealDB and the externally-maintained Esperanto/content-core/podcast-creator libraries, but overall the codebase is actively maintained and of professional quality.
AppFlowy is an open-source AI workspace application (Notion alternative) with a Rust backend and Flutter frontend. The system provides document editing, database views (grid/board/calendar), AI chat and completion, cloud sync, collaboration, file storage, and search. It employs a modular, event-driven architecture using a custom plugin system (lib-dispatch) and protobuf code generation. The backend is split into many small crates with clear trait abstractions for cloud services, storage, and field types. Notable strengths include a well-structured database type-option system, a priority task scheduler, and support for local AI via Ollama. Weaknesses include a complex dependency graph, custom build tools, and some duplicate test infrastructure. Overall, it is a high-quality, actively developed product with strong engineering practices.
Epicenter is a monorepo platform for building local-first, privacy-focused productivity applications with optional cloud sync. It encompasses a suite of apps including Honeycrisp (notes with Yjs CRDT sync), Whispering (voice transcription/dictation with local and cloud providers), Matter (typed markdown vaults with SQLite projection), Local Mail (Gmail mirror with offline triage), Local Books (QuickBooks mirror with CLI tools), Vocab (AI language tutor), Skills (agent instruction management), and the Epicenter desktop host (Tauri + Bun sidecar). The shared platform provides a CRDT-based data layer (Yjs with Durable Object authority), portable blob storage (IndexedDB, OPFS, S3), an OAuth/infrastructure-agnostic auth system, an agent loop framework with tool catalogs, and a server framework built on Hono for Cloudflare Workers or Bun. The architecture emphasizes offline-first, typed error handling (Result/defineErrors pattern), compile-time platform seams (browser/Tauri/desktop-host), and rigorous ADR-driven design with evidence benchmarks.
Saber is a production-grade, cross-platform Flutter application for handwritten note-taking. It is a monolith app with a few standalone packages: a custom vector-ink canvas engine (pen, pencil, highlighter, shape pen, laser pointer), page-based editor, image/PDF/SVG insertion, Quill text overlays, background patterns, shape recognition, and undo/redo. The main entry point is lib/main.dart, which wires routing, i18n, Sentry consent, sharing intents, and background sync. Notes are stored as versioned binary .sbn2 files via the self-contained packages/sbn library, with legacy .sbn support and migration logic. The application persists notes through a file manager responsible for CRUD, import/export, recently-used tracking, and directory watching. Nextcloud sync is implemented over WebDAV with client-side end-to-end encryption: file paths are hex-encrypted, content is encrypted, and conflicts are resolved using last-modified timestamps and a best-file strategy. Settings are managed through typed stow preferences and a large settings surface covering theme, writing tools, editor behavior, performance, and error reporting. Platform runners exist for Android, iOS, macOS, Windows, and Linux, with distribution metadata for Play Store, F-Droid, Flathub, AppImage, Snap, and Windows installers. The codebase is well-tested with unit, widget, golden, and format-compatibility tests, plus CI workflows for all major platforms. It is not a data/research repository; there are no notebooks, ML pipelines, or analytical datasets. Technical drift is moderate: the interactive canvas is a maintained fork of Flutter's InteractiveViewer, some dependencies are pinned or patched for F-Droid builds, and generated i18n files plus legacy format migration code require ongoing upkeep. Overall, this is a mature, actively maintained application with several cleanly separated components that can be reused in other Flutter projects.
This repository is a CSS theme for the Obsidian note-taking application, designed to replicate the visual aesthetic of the Things 3 task manager. The codebase consists of a single `theme.css` file that overrides Obsidian's default styling using CSS custom properties, class overrides, and media queries. It provides both light and dark color schemes, custom checkbox icons via CSS mask images, progress bar coloring based on percentage, and extensive integration with community plugins like Kanban, Calendar, Todoist, and Checklist. The theme also includes a comprehensive set of user-customizable settings exposed through the Style Settings plugin. This is a pure presentation layer with no application logic, data processing, or dependencies beyond Obsidian itself.
Joplin is a mature, cross-platform note-taking and synchronization application built on a monorepo architecture using Yarn Workspaces. It comprises four primary application layers: a desktop client (Electron/React), a mobile client (React Native), a CLI tool (Node.js), and a self-hosted server (Node.js/Koa). The core business logic resides in `packages/lib`, which handles data models (Notes, Folders, Tags), encryption (E2EE), and synchronization protocols (WebDAV, Joplin Server, Dropbox, etc.). The codebase demonstrates strong engineering practices with TypeScript, Redux state management, and a robust plugin system that allows third-party extensibility via a defined API. It supports multiple editor backends (CodeMirror, ProseMirror, TinyMCE) and integrates native modules for performance-critical tasks like OneNote parsing (Rust) and voice transcription (Whisper).
TriliumNext/Trilium is a full-stack, cross-platform hierarchical note-taking application with rich text editing, LLM integration, sync, encryption, and a plugin-based architecture. The monorepo contains a Node.js Express server (SQLite backend), a Preact/React SPA client, an Electron desktop wrapper, a standalone browser-SQLite-WASM build, and a Capacitor mobile app. The system manages notes as a tree with cloning, attributes, relations, and multiple content types (text, code, mind maps, canvases, spreadsheets, calendars, etc.). It provides custom CKEditor5 plugins for math, footnotes, mermaid diagrams, and AI assistance, as well as a full-featured LLM chat with tool execution and skill sheets. The codebase is well-tested with over 2000 spec files, uses modern TypeScript and pnpm workspaces, and includes comprehensive import/export (Evernote, OneNote, Obsidian, Notion, Google Keep, OPML, Markdown, HTML) and sync capabilities. Key architectural patterns include a provider abstraction for platform-specific services (crypto, zip, messaging, clipboard), a component-based widget system on the client, and a centralized entity cache (becca/froca) that is synchronized via WebSocket.
Butterfly is a cross-platform, open-source note-taking application built with Flutter, offering an infinite canvas for drawing, writing, and organizing notes. It supports a wide range of tools including pen, eraser, shape, text, laser, ruler, stamp, and area management, along with features like layers, pages, waypoints, backgrounds, textures, and real-time collaboration via WebSocket or Swamp protocols. The application can export to PDF, SVG, PNG, and Xournal++ formats, and integrates with WebDAV for file synchronization and backup. It is available on Android, Windows, Linux, macOS, iOS, and web platforms. The architecture follows a BLoC/Cubit pattern for state management, with a clear separation of concerns: handlers manage tool interactions, renderers draw elements on the canvas, and selections provide property editing UIs. The core data models are defined in a separate Dart package (`butterfly_api`) using freezed and json_serializable for immutable, serializable objects. The app uses a custom file system abstraction (`lw_file_system`) to support local, WebDAV, and Android SAF storage backends. Keyboard shortcuts are declaratively defined via an Action/Intent system, and the app supports embedding via a postMessage bridge for iframe integration. Key entry points include `app/lib/main.dart` for app bootstrap, `app/lib/bloc/document_bloc.dart` for central document state, and the various handler and renderer files in `app/lib/handlers/` and `app/lib/renderers/`. The application relies on external dependencies such as Flutter SDK, flutter_bloc, freezed, archive, phosphor_flutter, pdfrx, and material_leap. The codebase is actively maintained with frequent releases, extensive localization (20+ languages), and a comprehensive documentation site built with Astro/Starlight.
VimWiki is a mature Vim/Neovim plugin implementing a personal wiki system for note-taking, task management, documentation, and diary keeping. It features syntax highlighting for multiple markup languages (default VimWiki, Markdown, MediaWiki), wiki link resolution, table formatting, tag generation, and HTML export. The architecture follows a modular autoload pattern with scoped variable management (global, wiki-local, syntax-local, buffer-local) enabling flexible configuration. Core functionality includes link handling, diary automation, and text object manipulation for lists/tables. The project maintains active development with comprehensive testing across Vim/Neovim versions via CI, demonstrating strong adherence to Vim plugin best practices.
MiaoYan is a local-first macOS Markdown note-taking application (Swift 6, AppKit, macOS 12+) that treats notes as plain .md/.markdown/.txt files in a user-selected folder. In production it is a desktop editor: an FSEvents watcher detects external file changes, cmark-GFM renders Markdown through a single pipeline, and a WebKit preview surface (vendored KaTeX, Mermaid, PlantUML, Markmap, Reveal.js) handles rendering. The app ships wikilinks/backlinks, version history, CJK-aware typography normalization, PDF/HTML/PNG/PPT export, and URL routing (miaoyan://, nv://, nvalt://). There is no server component — cloud sync is deliberately delegated to iCloud Drive/Nutstore/Dropbox. Distribution includes Sparkle auto-update, Homebrew, App Store, a bash CLI (miao), and an agent-facing SKILL.md. The architecture is a monolith with two UI shells: the primary AppKit storyboard window (ViewController, EditTextView, SidebarProjectView) and an in-progress SwiftUI shell launched via -MiaoYanShell YES. Both shells share the Business/ layer, with dedicated parity tests keeping them aligned. A Foundation-only MiaoYanCore package holds platform-agnostic text logic (frontmatter parsing, multi-encoding detection, search matching, preview extraction) shared with an iOS build — the cleanest architectural boundary in the repo. Core domain services include Storage/Note/Project models, NoteVersionManager, WikilinkIndex, CloudSyncManager (NSMetadataQuery-based), and debounced atomic saves using renamex_np RENAME_SWAP. Engineering strengths: an extensive regression-driven test suite (26+ files) covering real incident history (editor buffer ownership #543, storage relocation, save debounce, shell parity), strict CI where SwiftLint and swift-format warnings block merges, tiered highlighting for very large files, xattr-based note metadata, legacy encoding support (UTF-8/UTF-16/GB18030/Big5/CP1252), and localization in five languages. Notable weaknesses: ViewController is a god-class accumulating layout/keyboard/storage/preview/PPT logic; the dual-UI shell carries ongoing parity risk; saveCloudPins/restoreCloudPins are empty stubs (cloud pin sync is unimplemented); large hand-maintained regex sets in NotesTextProcessor; UserDefaults key sprawl; two Package.resolved manifests with a Sparkle version mismatch (2.8.0 vs 2.9.0); and a large vendored DownView.bundle JS payload that is an update/maintenance burden.
fylepad is a note-taking application built with Vue 3 and Tauri that provides a rich text editing experience with AI integration. It functions as both a web application and cross-platform desktop app, offering features like markdown editing, diagram support (Mermaid, PlantUML), media embeddings (YouTube, Spotify), and AI-powered text assistance. The application uses a local-first approach with IndexedDB/SQLite storage and optional cloud synchronization. The architecture follows a component-based pattern with Vue.js, utilizing Tiptap for the core editor functionality and numerous extensions for specialized features. State management is handled through Vue composables, and the UI is built with @nuxt/ui components. The application includes sophisticated features like offline support, conflict resolution, and a responsive interface that adapts between web and desktop contexts.
This repository is the Meta Bind plugin for Obsidian, a note-taking application. It allows users to embed interactive input fields, view fields, buttons, and tables directly into Markdown notes, bound to frontmatter metadata or in-memory data. The plugin parses a custom DSL (e.g., `INPUT[type: text]`, `VIEW[...]`, `BUTTON[...]`) using a custom parser library (parsinom) and renders Svelte components that read and write metadata values. It supports over 20 input field types (text, number, slider, toggle, select, date, etc.), view fields with math expressions and markdown rendering, and button actions (commands, JS execution, note creation, metadata updates, etc.). The architecture is a monorepo with three packages: `core` (platform-independent logic), `obsidian` (Obsidian desktop adapter), and `publish` (Obsidian Publish adapter). The core package contains all parsing, configuration, field implementations, metadata management, and Svelte UI components. The obsidian package integrates with Obsidian's plugin API, CodeMirror editor, and metadata cache. The publish package provides a limited subset for Obsidian Publish. In production, the plugin operates as a Markdown post-processor and a CodeMirror view plugin. When a note is rendered, it scans for DSL declarations, parses them into field configurations, creates mountable field components, and binds them to metadata sources (frontmatter, YAML, in-memory caches). Changes in input fields propagate back to metadata and trigger updates to other bound fields. The plugin also provides a public API for other plugins (e.g., JS Engine) to create fields programmatically. External dependencies include Obsidian's own API, and optional integrations with the Dataview, Templater, and JS Engine plugins. The codebase demonstrates strong software engineering practices: clean separation of concerns, extensive use of factory and strategy patterns, a reactive metadata subscription system, and a comprehensive test suite. However, there are signs of technical drift such as commented-out code, some type safety workarounds, and a large parameterized test file that is difficult to maintain. Overall, it is a well-crafted, feature-rich plugin with reusable components that could be extracted for other projects.
TidGi-Desktop is a cross-platform Electron application that integrates TiddlyWiki (a personal wiki) with AI agent capabilities, Git synchronization, and modern desktop features. It allows users to manage multiple workspaces (folder-based or single-file HTML wikis), sync with Git remotes, and interact with AI agents for chat, tool execution, and knowledge management. The architecture is Electron multi-process with main process, renderer processes (multiple windows), and a utility process for wiki worker. Services are wired via Inversify DI container and communicate via typed IPC (electron-ipc-cat). Key entry points include src/main.ts (Electron main), src/renderer.tsx (React renderer), src/services/agentInstance/ (AI agent lifecycle), src/services/wiki/ (wiki management), and src/services/git/ (Git operations). External dependencies include TiddlyWiki, Git (via dugite), SQLite (TypeORM), various AI SDKs (OpenAI, Anthropic, etc.), OAuth providers, and system-level integrations. The codebase is well-structured with a service-oriented architecture, extensive test coverage (unit, E2E, BDD), and a rich preference system driven by Zod schemas. It demonstrates high craftsmanship in areas like AI prompt concatenation, tool registration, and file system watching, though some modules are tightly coupled to the application's domain.
ZotLit is a dual-plugin system (Obsidian plugin + Zotero addon) that bridges Zotero's reference management with Obsidian's note-taking environment. It enables users to create literature notes from Zotero items, insert formatted citations, import annotations, and export documents via Pandoc — all within Obsidian. The system is a monorepo with three main applications: an Obsidian plugin (apps/obsidian) that provides views (annotation sidebar, references panel, citation popover, template data explorer), services (citation indexing, live updates from Zotero, Pandoc integration, note creation/update), and a settings tab; a Zotero addon (apps/zotero) that extends Zotero's menus, database status, and freshness signaling; and a documentation site (apps/docs) built with TanStack Router and Fumadocs on Cloudflare Workers. The architecture is service-oriented on the Obsidian side, with approximately 20 services wired in a service container (build.ts) using AsyncDisposableStack for lifecycle management. Shared packages (@zotlit/db, @zotlit/templates, @zotlit/protocol, @zotlit/obsidian-i18n, @zotlit/item-lookup) provide database queries over Zotero's SQLite via Drizzle ORM, template rendering with Eta/Liquid engines, a versioned HTTP wire protocol between Zotero and Obsidian, i18n Language Pack compilation, and a search index for item lookup. The codebase is well-tested with Vitest, employs modern TypeScript patterns, and maintains a comprehensive typed contract system for template data. Key workflows include: bidirectional citation linking (pandoc-style and wikilink), live preview of citations in reading view, annotation import from PDF/EPUB/snapshots with turndown HTML-to-Markdown conversion, Pandoc export with a bundled Lua filter and pinned WASM engine, batch note creation from collection selections, and a template workbench CLI for debugging and authoring templates. The system relies on Zotero's local SQLite database as the authoritative source, with a freshness detection mechanism (WAL checkpoint polling) to trigger updates in Obsidian.