Queryx is a schema-first, type-safe ORM for Go and TypeScript. It provides a CLI tool that parses HCL schema files, manages database migrations using Atlas, and generates type-safe ORM client code for both Go and TypeScript. The codebase is well-structured with clear separation of concerns: schema parsing (schema/), database adapters (adapter/), code generation (generator/), and string inflection utilities (inflect/). It supports PostgreSQL, MySQL, and SQLite. The project includes comprehensive integration tests and CI/CD pipelines. While still in beta (v0), it demonstrates solid engineering practices with template-based code generation, fluent query builders, and support for associations, transactions, and custom primary keys. The generated code is type-safe and includes its own type wrappers for nullable fields and JSON serialization.
This is a self-hosted social timeline application (moments/朋友圈) that allows users to post short updates (memos) with rich media: images, videos, music, links, and Douban (Chinese media database) book/movie references. The architecture is a single Go binary that embeds a Nuxt.js static frontend and connects to a SQLite database. The backend provides a REST API with JWT authentication, supports file upload (local or S3), comment system with email notifications, RSS feed generation, and database backup on version changes. Noteworthy features include automatic database backup with cleanup, image thumbnail generation, Google reCAPTCHA integration, and a calendar-based search for memos. The codebase is well-organized with dependency injection (samber/do), proper route grouping, and data migration scripts. The frontend is a Nuxt 3 SPA with Tailwind CSS and component-based UI. The project is actively maintained with frequent commits and a responsive issue tracker.
MTG Familiar is a mature, open-source Android companion app for Magic: The Gathering. It provides a comprehensive suite of offline-capable tools including card search with advanced filtering, life counter with commander damage and poison tracking, mana pool, dice roller, trade and wishlist management, round timer, comprehensive rules browser, judge documents (MTR, IPG, JAR), deck builder with import/export and statistics, and the MoJhoSto random card generator. The app is built as a single-module Android project using AndroidX, with a local SQLite database for card data (updated via JSON patches from a GitHub repository), TCGPlayer API integration for market prices, and Glide for card image loading. The architecture follows standard Android patterns: a main Activity (FamiliarActivity) manages a navigation drawer and fragment transactions, with each tool implemented as a Fragment. Data access is centralized through CardDbAdapter and DatabaseManager, with custom Views for mana symbols, color pie, and token-based input. The codebase is well-organized but shows signs of age with deprecated API usage (AsyncTask, PreferenceFragment) and some large, tightly-coupled fragments. It is actively maintained (last commit 2026-06-04) with regular database updates and community contributions.
Telecrawl is a Go CLI application that imports Telegram Desktop's `tdata` session data and creates encrypted, versioned backups. It reads the local Telegram Desktop data directory (platform-specific paths for macOS/Linux), parses the tdata format, and stores chat archives in a SQLite-backed store with merge/restore/tombstone semantics. The CLI exposes commands for import, backup, restore, search, and media reference handling. It runs as a Docker image with a non-root user, read-only tdata mount, and persistent /data volume. Architecturally, it is a monolith with a `cmd/telecrawl` entry point delegating to `internal/cli`, which orchestrates importers (`tdata`, `postbox`) and the `internal/store` persistence layer. The store handles schema migrations, snapshot merging, and search. Backup uses a Git remote pattern with safety guards against path overlaps. The codebase includes CI workflows, release automation, and security checks. Maintenance is active with frequent dependency bumps and CI. However, the store package is large and mixes concerns, and tdata/postbox importers are format-specific and may break if Telegram changes its data format. Hardcoded platform paths and schema backfill migrations are drift risks. Despite some data-audit scripts and fixture data, the dominant character is a CLI application.
WeWe RSS is a monolithic NestJS application that provides RSS feed generation for WeChat public accounts (微信公众号). It acts as a middleware between the WeRead (微信读书) platform and standard RSS readers. The system allows users to add WeChat public accounts via article links, fetches account metadata and article lists through the WeRead platform API, stores them in a MySQL or SQLite database, and exposes RSS/Atom/JSON feeds. It includes a cron-based scheduler for periodic feed updates, an admin dashboard built with React and NextUI, and supports features like full-text extraction, title filtering, and OPML export. The architecture is typical for a NestJS application: controllers handle HTTP requests, tRPC provides a type-safe API layer for the frontend, Prisma ORM manages database interactions, and the frontend is a separate Vite/React app. The codebase is straightforward and functional, with no standout reusable components that could be easily extracted without modification.
This repository is a Unity-based MMORPG framework that extends the MultiplayerARPG template to support a multi-server architecture with central, map, and database servers. The client provides a full pre-game UI flow (login, registration, server/channel selection, character creation) and in-game features such as guilds, parties, mail, cash shop, gacha, storage, and IAP validation. The server is component-based, with CentralNetworkManager handling authentication and character operations, MapNetworkManager managing per-map gameplay and persistence, and DatabaseNetworkManager abstracting SQLite/MySQL storage. Data flows involve periodic saving of player and building state via data updaters with hash-based change tracking, and caching of social data (parties, guilds) with configurable refresh intervals. External dependencies include LiteNetLib for networking, SQLite/MySQL for databases, and custom ASN.1 parsers for Apple/Google Play receipt validation. The codebase demonstrates modular design through interfaces (IDatabaseClient, IChatProfanityDetector, IIAPReceiptValidator) and reusable utilities (MiniJSON, Asn1Processor).
Clipy is a macOS clipboard extension app that lives in the menu bar. It provides clipboard history management, text snippet storage and quick paste, OCR for image-based clipboard content, and customizable global hotkeys to trigger history menu, snippet editor, or paste actions. The app monitors NSPasteboard using a timer, deduplicates entries, and stores them in a local SQLite database (via GRDB wrapper SQLiteData), with a legacy Realm database still present for migration. UI is built with a mix of SwiftUI (settings panes) and AppKit (snippet editor, menu). Dependency injection via swift-dependencies and reactive storage via swift-sharing are used throughout. The architecture is well-modularized with repository and service layers, extensive unit tests, and a migration system for both database schema and user defaults. However, the project shows signs of drift: legacy Realm code and XIB files persist, localization strings may be out of sync, and the last commit date is anomalous (future date) suggesting the project may be unmaintained despite a large user base.
Lavandula is a lightweight C web framework designed for building small web applications quickly. It provides HTTP server functionality with routing, middleware pipeline support, SQLite3 integration, and a built-in JSON library. The framework includes a CLI tool (lavu) for project scaffolding and features a 'hot restart' mechanism for development. The codebase is well-organized with clear separation of concerns between HTTP parsing, routing, middleware, and database operations. However, the README explicitly states it's in early development and not production-ready, with several features still in progress including multithreading, TLS, rate limiting, and the Lavender ORM layer. The framework demonstrates solid C engineering practices with proper memory management, error handling, and a comprehensive test suite covering core components like JSON parsing, authentication, CORS, and HTTP parsing.
Upstat is a self-hosted, open-source status monitoring and uptime tracking tool. The system consists of a Go (Fiber v2) backend API and a Next.js 15 web dashboard, deployed via Docker Compose with support for both PostgreSQL and SQLite databases. The backend periodically pings configurable HTTP endpoints, records heartbeats, calculates uptime percentages, and manages incidents triggered by status transitions. It integrates with multiple notification channels (Discord, Slack, Telegram, Ntfy, Gotify) and provides public status pages with real-time latency charts. The frontend uses shadcn/ui components, React Hook Form with Zod validation, and a custom client fetch wrapper for authenticated API calls. The monorepo also includes a documentation site (Fumadocs) and a static landing page. While the architecture is well-structured with clear separation of concerns (controllers, routes, models, utils), the codebase shows signs of technical drift including outdated dependencies, hardcoded secrets in Docker Compose files, committed SQLite database artifacts, and documentation inconsistencies between the manual API docs and generated OpenAPI spec. The project is functional and suitable for small to medium deployments but would benefit from dependency updates and cleanup before production use.
This is the OpenIM SDK Core, a cross-platform instant messaging client SDK written in Go. It provides the core messaging functionality—send/receive messages, manage conversations, groups, friends, user profiles, and file uploads—for the OpenIM ecosystem. The SDK communicates with an OpenIM server via HTTP REST and WebSocket long connections, and persists data locally using SQLite (native) or IndexedDB (WebAssembly). It features robust incremental synchronization, a callback-driven architecture for event handling, and extensive support for multiple platforms (iOS, Android, Windows, macOS, Linux, Web). The codebase demonstrates solid engineering practices with generic sync engines, caching utilities, and a comprehensive integration test suite. However, it also contains notable code duplication (dual native/WASM storage implementations), incomplete WASM stubs, some panic-based error handling, and alpha-stage dependencies, which prevent it from being exceptional. Overall, it is a functional, actively maintained SDK with reusable patterns for incremental sync and WebSocket connection management.
Android Debug Database is an Android library that provides a web-based interface for debugging databases and shared preferences in Android applications. When included in an app's debug build, it starts a lightweight HTTP server that serves a web UI allowing developers to inspect databases, run SQL queries, edit data directly, and manage shared preferences. The architecture consists of a core library (debug-db-base) that handles server logic and database interactions, with optional modules for encrypted database support (debug-db-encrypt) and sample applications demonstrating usage. The system uses a client-server model where the server runs inside the Android app and the client is a standard web browser connecting via HTTP to localhost. Key features include support for SQLite databases, Room databases (including inMemory), SharedPreferences, and SQLCipher-encrypted databases, with a responsive web interface built using Bootstrap, jQuery, and DataTables.
ZhihuHelper is a desktop application built with Electron, React, and Node.js designed to scrape content from Zhihu (a Chinese Q&A platform) and export it to EPUB/HTML formats for offline reading. The application features a GUI for task configuration and logging, alongside a CLI interface powered by AdonisJS Ace. Core functionality includes fetching various Zhihu content types (answers, articles, pins, collections, etc.) via the platform's API, storing data in a local SQLite database, and generating formatted e-books with options for sorting, image quality selection, and automatic volume splitting. The architecture separates concerns into distinct layers: Electron main process for window management and IPC, React renderer for the UI, API wrappers for Zhihu endpoints, Knex-based ORM models for data persistence, and a custom EPUB generation library. While the tool effectively accomplishes its stated purpose, it exhibits signs of technical drift due to outdated dependencies and reliance on Zhihu's undocumented API, which necessitates frequent maintenance to remain functional.
APIMyLlama is a Node.js application that serves as a proxy and management layer for the Ollama API. It provides an endpoint (/generate) to interact with LLMs using API keys, which are managed via a command-line interface. The application includes features such as API key generation, validation, rate limiting, webhook notifications, and dynamic configuration of server port and Ollama URL. The architecture is monolithic, leveraging Express for HTTP handling, SQLite for persistence, and a custom CLI for administrative tasks. Key components include rate limiting middleware and a webhook notification system, which demonstrate common patterns in API management. However, the project suffers from dependency issues where the version constraints for axios and express are set to versions (>=1.13.5 and >=5.2.1) that are not currently available, preventing installation with the latest stable packages. This indicates a lack of maintenance in terms of dependency updates, despite recent commits.
Reels-AutoPilot is a Python automation application that scrapes short-form video (Instagram Reels and YouTube Shorts) from configured creator accounts and reposts that content to the user's own Instagram account, including optional story cross-posting. The architecture is a small monolith of loosely coupled scripts sharing a SQLite database: app.py is the main orchestrator running an infinite scheduling loop, reels.py and shorts.py scrape content via instagrapi/yt-dlp, poster.py uploads clips and stories, remover.py purges posted files, and db.py/helpers.py provide SQLAlchemy persistence plus a config system where SQLite values override static defaults in config.py. A Rich-based terminal dashboard (dashboard.py) shows live posting status, and start.py is an interactive CLI setup wizard. The core data flow is: scrape → download to downloads/ → insert metadata row into the 'reels' table as unposted → poster loop picks the oldest unposted row → upload as an Instagram clip → mark posted → optionally trim to 15s and post as a story with mention/link/hashtag/media stickers → remover deletes the local file after a configurable interval. External dependencies are the unofficial Instagram client instagrapi, the YouTube Data API v3 with yt-dlp, moviepy for video trimming, SQLAlchemy, and Rich. The code is functional but rough: reels.py has a filter bug (a tuple instead of a boolean condition) that lets non-reel media into the database; dashboard.py compares string config values to integers so status toggles always render as 'Off'; start.py validates the wrong variable in two input loops; exceptions are silently swallowed; and Instagram credentials are stored in plaintext in both config.py and the SQLite DB, with database/sqlite.db committed to the repository (a credential-leak risk). There are no tests or CI, and the README advertises features (scheduling, multi-account, auto-hashtags, analytics) that do not exist in the code. Dependency versions are somewhat dated, with moviepy 1.0.3 (circa 2020) the most notable lag. The YouTube channel-resolution helpers and the instagrapi story-sticker composition are the most genuinely reusable pieces.