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.
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.
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.
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.
Jotty (formerly rwMarkable) is a full-stack, self-hosted productivity application for managing notes, checklists, and Kanban boards. It uses Next.js 16 (App Router), React 19, and TypeScript with a file-based storage system (Markdown files with YAML frontmatter). Key features include rich text editing (TipTap with custom extensions for diagrams, callouts, mentions), drag-and-drop (custom DnD engine for Kanban, @dnd-kit for checklists), user management with multiple authentication methods (local, LDAP, OIDC), MFA (TOTP), encryption (PGP, XChaCha20), granular sharing with permission inheritance, version history via Git, full-text search using grep, audit logging, and a PWA with offline support. The architecture is server-first with Next.js server actions for all mutations and a WebSocket broadcast for real-time updates. The codebase is well-organized with a clear separation of concerns: global UI components, feature-specific components, server actions, types, utilities, and hooks. It has extensive test coverage (Vitest) across server actions, API routes, utilities, and security. While file-based storage imposes scalability limitations, the application demonstrates high craftsmanship in its modular design, custom drag-and-drop implementation, encryption handling, and sharing system. It is actively maintained with regular releases and community contributions.
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.
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.
Notty is a full-stack, cross-platform notes application (an Apple Notes-style clone) built with a React 19 + Vite + Tailwind 4 frontend, a Hono API running on Cloudflare Workers, and per-user Durable Objects that each own a SQLite database. Clients include a web app, a Tauri 2 desktop app (with local SQLite, markdown export/import, cloud sync, deep-link auth, and a quick-note hot corner), and a mobile variant. Realtime collaboration is powered by Yjs with three persistence paths (Durable Object SQLite, browser IndexedDB, and Cloudflare R2), and authentication uses Better Auth with passkeys, Google/GitHub/Apple social login, and anonymous sessions. The backend also serves server-rendered public pages generated from TipTap JSON with URL sanitization and RSS 2.0 feeds, and integrates Supermemory for AI-powered note indexing. File storage and full version-history snapshots live in R2, with branch management (create/checkout/merge/delete), diff views, and restore-with-auto-backup. The architecture is notable for its platform adapter pattern (web/desktop/mobile adapters abstracting storage and sync) and per-user Durable Object isolation, but the codebase carries meaningful baggage: dead code from an earlier NextAuth-based iteration (src/lib/auth.ts, old NotesContext, DarkModeSwitch, search-results.tsx), no visible unit tests beyond a race-condition QA script, a non-standard FNV-1a-based lock token instead of a real HMAC, and a merge operation that is actually a replace. Optimistic update logic in the notes context is fragile and can diverge from server state under rapid tab switches. Despite these issues, the core architecture is sound and the adapter pattern is genuinely reusable.