This repository is a Go library that implements a database/sql driver for SQLite3, using cgo to bind to the SQLite C library (either the bundled amalgamation or a system-installed libsqlite3). It provides a full-featured driver supporting transactions, prepared statements, custom functions, aggregators, collations, hooks, virtual tables, backup, serialization, and many SQLite extensions via build tags. The architecture is a single-package driver with a large cgo file (sqlite3.go) and numerous optional feature files selected by build constraints. Key entry points are the SQLiteDriver, SQLiteConn, SQLiteStmt, and SQLiteRows types, which implement the standard database/sql interfaces. The codebase is mature, widely used, and actively maintained, with extensive tests and CI across platforms. It is not a standalone application but a reusable library consumed by Go programs.
Sidequest.js is a Redis-free background job processing system for Node.js/TypeScript that provides distributed, durable job processing using existing databases (PostgreSQL, MySQL, SQLite, MongoDB). The system features a modular monorepo architecture with separate packages for core logic, engine, database backends, web dashboard, and CLI tools. It implements job lifecycle management, scheduling via cron expressions, uniqueness constraints, retry mechanisms with backoff strategies, and provides a web interface for monitoring and management. The architecture follows clean separation of concerns with dependency injection, worker thread isolation via Piscina, and process isolation through forked child processes. Key entry points include the main Sidequest facade, engine configuration, dashboard interface, and CLI administration tools.
wacrawl is a local-first Go application for importing, merging, searching, and exporting WhatsApp Desktop archive data. It reads the WhatsApp Desktop SQLite database directly from local files, normalizes it into a private SQLite store, and exposes a CLI (import, status, chats, messages, search, sql, web, backup, contacts, metadata) plus a loopback-only read-only web viewer. The system is deliberately private: no network protocol, media confined to known roots, and the web UI requires a per-run bearer token.
graincrawl is a local-first CLI tool written in Go that archives Granola meeting notes, transcripts, panels, and metadata into a private SQLite database. It supports multiple read-only source adapters: Granola's private desktop API (via WorkOS token), the official public API (with a scoped API key), the local plaintext desktop cache, and legacy encrypted JSON files (via Electron safeStorage decryption). The tool provides commands for syncing, searching, exporting Markdown, creating portable snapshots, and browsing via a terminal UI. The architecture is cleanly modular with separate packages for each source adapter, a shared SQLite store with schema migrations, and a syncer that orchestrates fallback logic between sources. The codebase is well-tested, has comprehensive CI/CD, and follows Go best practices. It is not a data research project; it is a production-grade application for personal data archiving.
claude-mem is a persistent memory system for AI coding assistants, primarily targeting Claude Code but also supporting Codex, Cursor, Windsurf, OpenClaw, and other platforms. It captures observations, summaries, and user prompts from coding sessions via lifecycle hooks (SessionStart, PostToolUse, etc.), stores them in SQLite (local) or Postgres (server), and injects relevant context into future sessions to maintain continuity across agent interactions. The system operates as a background worker daemon (Bun) or a multi-user server (Express + BullMQ + Valkey) with API key authentication, team/project scoping, and rate limiting. Architecturally, claude-mem is a hybrid of a CLI plugin and a standalone server. The CLI component integrates into IDEs via hook scripts and MCP servers, while the server component provides REST APIs for memory management, search, and cloud sync. It features a dual-storage backend (SQLite for local, Postgres for server) with vector search via ChromaDB and full-text search via SQLite FTS5. The system includes a React-based viewer for browsing memory feeds, telemetry (opt-out PostHog), and a Cloudflare Workers-based sync hub for cross-device synchronization. The codebase demonstrates strong engineering practices with well-abstracted components (search strategies, provider abstraction, atomic file operations, telemetry scrubbing) but carries some technical debt from its dual-runtime evolution (legacy worker vs. server-beta) and extensive Windows-specific workarounds. It is actively maintained with frequent releases and comprehensive test coverage.
DBeaver is a universal database management tool and SQL client, built as a desktop application on the Eclipse RCP (OSGi plugin) framework. It provides a rich graphical interface for connecting to over 100 database systems via JDBC/ODBC drivers, including relational databases (MySQL, PostgreSQL, Oracle, SQL Server, SQLite, etc.), cloud databases (BigQuery, Athena, Snowflake), and NoSQL systems (MongoDB, Cassandra) in commercial editions. The application offers a full suite of database development features: a multi-tab SQL editor with syntax highlighting, code completion, and execution plan visualization; a data editor with grid, form, and GIS geometry views; ER diagram designer; data export/import wizards supporting CSV, JSON, XML, SQL, Markdown, and Excel; dashboard widgets for query-based monitoring; and an integrated AI assistant (OpenAI, Copilot) for natural language query generation and schema analysis. The architecture follows a strict model/UI separation enforced by OSGi plugin boundaries. The core model plugin (`org.jkiss.dbeaver.model`) defines interfaces for database objects, data values, execution contexts, and security, which are implemented by database-specific extension plugins (`org.jkiss.dbeaver.ext.*`). UI plugins (`org.jkiss.dbeaver.ui.*`) provide editors, navigators, and dialogs, while data transfer, debugging, and AI features are isolated in their own plugins. This design allows the model layer to be reused in the web-based CloudBeaver product. Key entry points include the `DBeaverApplication` class for startup, the `SQLEditor` for query editing, and the `DataTransferWizard` for import/export. External dependencies include the Eclipse RCP framework, JDBC drivers, ANTLR4 for SQL grammar parsing, JSQLParser for SQL analysis, and various third-party libraries for SSH tunneling, AWS SDK, and AI API communication. Data flows center around database connections: users configure data sources via connection wizards, execute SQL queries through the editor, and view results in data grids or export pipelines. The data transfer subsystem implements a producer/consumer pattern with pluggable transformers and serializers, supporting streaming for large datasets. The AI integration uses a provider abstraction to interface with different LLM APIs, generating SQL from natural language and providing schema-aware context. The repository also includes a CLI tool (`dbvr`) for CI/CD automation and a headless test platform. While the community edition is fully open-source, commercial versions add NoSQL support, additional AI providers, and premium features, with some code paths guarded by feature flags.
Frappe Books is a full-featured, offline-first desktop accounting and inventory management application built with Electron, Vue 3, and a custom ORM framework (fyo) on top of SQLite. It supports double-entry bookkeeping, invoicing (Sales/Purchase/Returns), payment processing, stock management (batches, serial numbers, FIFO valuation), Point of Sale (classic and modern layouts), financial reports (Balance Sheet, P&L, Trial Balance, General Ledger, GST reports), loyalty programs, pricing rules, coupon codes, and multi-currency. The architecture is schema-driven: JSON schema files define document structures, and model classes add business logic via formulas, validations, and lifecycle hooks. The backend runs in the Electron main process and exposes IPC APIs for file operations, database access, and auto-updates. The frontend is a reactive Vue 3 SPA with a comprehensive component library. Regional support (India, Switzerland) is implemented through model overrides and schema extensions. The codebase demonstrates strong engineering practices with a layered architecture, but the custom framework introduces some coupling. It is actively maintained with CI/CD, automated tests, and regular patches.
Jitendex is a C# rewrite of the build system for a free, offline Japanese-to-English dictionary. It is fundamentally a multi-stage ETL pipeline: raw dictionary archives (JMdict, JMnedict, Kanjidic2, KanjiVG, Tatoeba, CHISE) are imported into SQLite databases, processed into a unified dictionary model with patches, furigana, headwords, cross-references, and integrity checks, then exported for use in Yomitan and MDict. The README explicitly states the rewrite is under construction and not yet production-ready; the legacy Python system still produces published releases. Despite that caveat, the codebase is a serious software engineering effort rather than research code, with console entry points, dependency injection, unit tests, and a modular library structure.
Vleer is a cross-platform desktop music player and local library manager written in Rust, positioned as a free, subscription-free alternative to commercial music streaming apps. The application scans a user's local music directories, extracts metadata (tags, cover art, embedded lyrics) using the lofty crate, stores everything in a SQLite database, and provides a rich GPUI-based interface for browsing albums, artists, playlists, and genres, with playback powered by a forked rodio audio backend. Architecture is a monolith: a single binary with a GPUI main window, backend services (scanner, database, telemetry, updater), and platform-specific media controllers (MPRIS on Linux, SMTC on Windows, Now Playing on macOS). Key data flows move from local files into the SQLite repository (with sophisticated dedup via content-based fingerprinting, spelling-vote normalization for artist/album names, and file relinking that preserves favorites when files move), then into in-memory search indexes and UI views; playback routes audio through an equalizer and FFT visualizer before output. External integrations include LRCLIB for synced lyrics, Last.fm for scrobbling, Discord Rich Presence, and the vleer.app OMM metadata/update/telemetry endpoints. From a reusability standpoint, the most valuable components are the audio fingerprinting module (src/data/fingerprint.rs), which does tag-independent content hashing across FLAC, OGG, MP3, WAV, AIFF, and MP4 containers with extensive tests, and the DSP module (src/media/equalizer.rs) implementing peaking biquad filters. The SQLite repository layer (src/data/db/repo.rs) demonstrates strong patterns for batch upserts, incremental relinking, and prepared-statement caching, though it is tightly coupled to the app's schema. The codebase shows professional engineering discipline: pinned Rust toolchain, CI enforcing fmt/clippy/audit/tests, nightly release automation with GPG-signed updates, and benchmark tests for database contention. Notable weaknesses include heavy duplication between albums/playlists views, stub menu actions, several very dense modules with globally raised cognitive-complexity thresholds, the use of forked dependencies (gpui-ce, rodio fork) that may drift, and a single ignored Cargo audit advisory. Overall this is a solid, well-structured early-stage application (v0.1.0) with genuine craftsmanship in specific modules, though its tight global-state coupling and early feature-completeness prevent it from being exceptional.
Sequelize is a mature, promise-based Node.js ORM supporting PostgreSQL, MySQL, MariaDB, SQLite, Microsoft SQL Server, DB2, IBM i, Oracle, and Snowflake. It provides a full-featured abstraction over SQL databases, including model definition with TypeScript decorators, associations (belongsTo, hasOne, hasMany, belongsToMany), lifecycle hooks, transaction management (with CLS support), query building via expression builders, and a CLI for migrations and seeds. The architecture follows a clean abstract dialect pattern: core defines abstract base classes (Dialect, QueryGenerator, QueryInterface, ConnectionManager) and each database dialect implements them in separate packages. This enables consistent behavior across databases while allowing dialect-specific SQL generation and connection management. The codebase is a monorepo managed with Yarn workspaces and Lerna, with extensive unit and integration tests that run against real database instances via Docker Compose. Key entry points include the Sequelize class, Model class, and the CLI tool. Data flows from application code through model methods (e.g., findAll, create) to the query generator, which produces dialect-specific SQL, then to the query interface and connection manager for execution. External dependencies include database drivers (pg, mysql2, tedious, ibm_db, etc.), validator.js, and utility libraries. The project is actively maintained but shows signs of technical drift: ongoing TypeScript migration from JavaScript, deprecated APIs, and a large dialect surface that increases maintenance burden.
LiteFS is a FUSE-based distributed filesystem for replicating SQLite databases across a cluster of machines. It operates as a Linux daemon that intercepts SQLite's file-level operations (journal, WAL, SHM) to capture every transaction. These transactions are recorded in a custom LTX (Lite Transaction) binary format and streamed to replica nodes via an HTTP/2 h2c protocol. The system uses leader election (via Consul or a static configuration) to designate a primary node that accepts writes, while replicas synchronously apply changes and enforce read-after-write consistency via TXID cookies and a proxy layer. The architecture is fundamentally a thin FUSE layer wrapping a distributed state machine: each node runs a store that manages multiple databases, tracks guards for SQLite lock compatibility (PENDING, SHARED, etc.), and exposes an HTTP API for streaming replication, manual imports/exports, handoff, and backup integration. The proxy server sits in front of the application to route read requests to the primary or a sufficiently caught-up replica, using Fly-Replay headers for transparent redirect. Backup is supported through either a file-based mechanism or the LiteFS Cloud client. External dependencies include Consul (for leader election), FUSE (required on Linux), and the underlying SQLite library (no cgo, pure Go via the ltxx package). The codebase is written in Go, with a heavy focus on correctness under concurrency—evidenced by extensive integration tests that exercise split-brain recovery, checkpoint races, and multi-node handoff. The project is in beta and follows a roadmap-driven contribution model where the maintainer rewrites feature PRs to ensure consistency.
dataset is a lightweight Python library that simplifies database operations by providing a dict-like interface on top of SQLAlchemy. It automatically creates tables and columns on insert, supports CRUD operations, transactions, and chunked bulk inserts/updates. The library is designed for small to medium-scale data tasks where full ORM overhead is unnecessary. It supports SQLite, PostgreSQL, and MySQL, and is fully type-annotated with mypy strict compliance. The codebase is well-organized into core modules (database, table, types, util, chunked) and has thorough test coverage across all supported backends. While the core abstraction is thin (intentionally), the implementation demonstrates solid engineering discipline with clean APIs, thread safety considerations, and proper handling of SQLAlchemy 2.x quirks.
Field Theory CLI is a local-first TypeScript application for managing X/Twitter bookmarks and building personal knowledge bases. It provides a comprehensive CLI interface for syncing bookmarks from Twitter/X (via OAuth API or browser session extraction), classifying content, exporting to markdown with wikilinks, generating interconnected wikis, and enabling agent workflows through skill installation for AI coding agents like Claude Code and Codex. The application features a 'Possible' idea generation pipeline that applies bookmark collections to repositories for innovation planning, with local data storage in ~/.fieldtheory/ using SQLite FTS5 for full-text search. Built with modular architecture separating concerns into bookmarks, ideas, agent context, and document operations modules.
golink is a private shortlink service (http://go/) for Tailscale tailnets. It allows users to create short aliases for URLs, supports Go text/template expansion for dynamic links, and integrates deeply with Tailscale identity and networking via the tsnet library. The architecture is a single Go binary that uses an embedded SQLite database for persistent storage and serves both a web UI (TailwindCSS + Go templates) and a JSON API. It handles user authentication through Tailscale's WhoIs mechanism, supports admin grants via ACL capabilities, and provides backup/restore via JSON Lines export. The codebase is well-structured, with clear separation between database operations (db.go), HTTP handlers and link resolution logic (golink.go), and the CLI main entry point. The repo includes comprehensive tests, Docker/Nix/Helm deployment options, and Prometheus metrics. It demonstrates high craftsmanship in areas such as idempotent snapshot restoration, template-based link expansion with path/query forwarding, and robust XSRF protection.
Pluton is a self-hosted, open-source backup application that wraps restic and rclone to provide scheduled, encrypted backups to a wide variety of cloud and local storage providers. The system is built as a full-stack monorepo with a Node.js/Express backend (TypeScript) and a React frontend (Vite), communicating via REST APIs. It manages backup plans, devices, storage locations, and restore operations through a web dashboard, with support for replication, retention policies, integrity checks, and multi-channel notifications (email, Slack, Discord, push). The architecture follows a layered pattern: controllers handle HTTP requests, services orchestrate business logic, stores encapsulate database access (SQLite via Drizzle ORM), and managers/strategies handle execution of backup, restore, and system operations using restic and rclone as child processes. A job queue with cron scheduling drives automated backups, and event emitters decouple progress tracking and notification dispatch. The frontend provides a rich UI with virtualized file browsers, snapshot viewers, and step-by-step wizards for plan creation and restore. The codebase is well-structured with extensive unit tests, CI/CD pipelines, and cross-platform installers (Docker, Linux AppImage, macOS, Windows).
This repository is a production-grade Discord bot for managing support tickets, built with TypeScript and the discord.js core library. It provides a complete ticket lifecycle: users open tickets via panels (select menus or buttons), staff can claim, close, reopen, rename, add/remove participants, and the bot generates transcripts via ticket.pm. The architecture follows a modular feature-based pattern with automatic discovery of commands, events, and feature modules from the filesystem. The bot uses SQLite (via drizzle-orm and libsql) for persistence, supports internationalization (English and French), and includes telemetry, update checking, and migration scripts from v3 to v4. Key entry points are the slash commands (/add, /claim, /close, /reopen, /remove, /rename, /unclaim, /cleardm, /mass_add) and interactive components (buttons, selects, modals). External dependencies include Discord API, libsql, drizzle-orm, ticket.pm SDK, and typesafe-i18n.
imsgcrawl is a local-first CLI tool for reading, archiving, and searching Apple iMessage data. It operates by taking a read-only snapshot of the macOS Messages SQLite database (`chat.db`), extracting handles, chats, messages, and deletion events, then merging them into a local SQLite archive. The tool provides bounded commands for metadata, status, sync, chats, messages, full-text search, and phone-only contact export. It outputs both human-readable text (with terminal control escape protection) and stable JSON for automation. The architecture is cleanly separated into packages for archive management, message extraction (including attributed body decoding and edit/unsend reconstruction), and portable SQLite snapshotting with macOS copy-on-write support. The codebase demonstrates strong engineering practices: thorough test coverage including fuzzing, explicit privacy boundaries, identity validation for source databases, and careful handling of edge cases like malformed UTF‑16, hardlinked sidecars, and concurrent sync locking.
notcrawl is a production-grade CLI tool for mirroring a Notion workspace into a local SQLite database and normalized Markdown files. It ingests data from three sources: the official Notion API, the local Notion Desktop cache (macOS), and an experimental Notion MCP gateway (via ChatGPT). The core architecture is a Go CLI with a unified SQLite store that tracks record provenance (source, sync timestamps, tombstones) and supports full-text search via FTS5. Key commands include `sync` (multi-source ingestion), `search`, `export-md` (Markdown tree), `export-db` (CSV/TSV for databases), `tui` (terminal browser), and `publish`/`subscribe` (git-backed snapshot sharing). The system emphasizes data completeness, deterministic rendering, and offline durability. External dependencies include the Notion API, local SQLite (desktop cache), and a git binary for share operations. The codebase is well-tested with extensive unit and integration tests, and follows clean separation of concerns across store, API, desktop, MCP, markdown, and share modules.
Crawlkit is a shared Go library and CLI tool (crawlctl) for building local-first crawler archives. It provides provider-neutral building blocks including SQLite stores with FTS5, snapshot/export to gzipped JSONL shards, Git-based mirroring with immutable tags, encrypted backup with age/gzip and SHA-256 deduplication, sync state management with legacy adapters, vector search (exact cosine similarity and optional turbovec Python bridge), embedding providers (OpenAI, Ollama, llama.cpp), a terminal UI (Bubble Tea) for browsing archive rows, and a remote archive client for Cloudflare Workers. The CLI discovers installed crawl apps (e.g., gitcrawl, discrawl) and runs configured refresh jobs under a single-process lock. The architecture is modular and composable, with clear ownership boundaries documented in docs/boundary.md. The repository also includes agent skills (autoreview, crabbox) for automated code review and remote validation, reflecting heavy agent-driven development. It is not a generic web crawler but a mechanics layer that makes each crawl app smaller and more uniform.
Loop Habit Tracker is a mature, open-source Android application for building and maintaining habits through daily check-ins, scoring, streaks, and detailed statistics. The system is architected as a Kotlin Multiplatform project with a shared core module (`uhabits-core`) containing all business logic, models, commands, and platform abstractions, and an Android-specific module (`uhabits-android`) providing the UI, widgets, notifications, and platform implementations. The core uses an MVP-like pattern with presenters, immutable state, and a command pattern for all habit mutations (create, edit, delete, archive, toggle checkmarks). Data is persisted locally in SQLite with a custom migration system supporting 25+ schema versions. The app features extensive home screen widgets (checkmark, score, streak, frequency, history, target), reminders with snooze, Tasker/Locale automation, CSV export, and import from other habit trackers (HabitBull, Rewire, Tickmate). External dependencies include AndroidX, Material Components, Ktor (for sync), AppIntro, and OpenCSV. The codebase demonstrates strong engineering practices: dependency injection via kotlin-inject, platform-agnostic canvas drawing for custom charts, a robust caching layer for list performance, and comprehensive test coverage including unit tests, instrumented UI tests, and snapshot-based rendering tests.