MySQL Workbench is a production-grade, cross-platform desktop application for MySQL database management. Its codebase is organized into a modular architecture: a core C++ backend using the GRT (Generic Runtime) object model for metadata-driven object management and plugin loading; a cross-platform UI abstraction layer (mforms) with platform-specific implementations for Linux (GTK), macOS (Cocoa), and Windows (.NET); dedicated packages for data modeling (EER diagrams, forward/reverse engineering), SQL editing (syntax highlighting, autocompletion, query execution), server administration (user management, performance monitoring), and data migration. The repository also bundles a custom ANTLR-based SQL parser, a canvas library for interactive diagramming, SSH connectivity support, and extensive SQL scripts for Performance Schema monitoring. While it contains analytical SQL scripts for database diagnostics, its core nature is a graphical application, not a data research project.
The repository provides the official PyTorch implementation of DoRA (Weight-Decomposed Low-Rank Adaptation), a parameter-efficient fine-tuning method. It integrates with Hugging Face PEFT and includes training/evaluation scripts for vision-language and language tasks (e.g., VQA, ScienceQA, commonsense reasoning). The architecture is modular, with core components like DoRA tuners, adapter controllers, and low-rank layers. Entry points include training scripts (finetune.py, train_dora.py), evaluation scripts (evaluate.py, run_llava.py), and serving tools (gradio_web_server.py). External dependencies include PyTorch, Transformers, PEFT, bitsandbytes, and dataset-specific libraries.
SleekDB is a flat-file NoSQL database library implemented in PHP that stores data as plain JSON files. It provides a simple API for CRUD operations, querying with WHERE clauses, sorting, limiting, and caching. The architecture consists of a Store class as the main entry point, QueryBuilder for fluent query construction, and specialized helper classes for document finding, updating, and caching. Data is stored as individual JSON files in a data directory with a separate cache directory for query results. The library requires no third-party dependencies beyond PHP 8.4+ with JSON and MBString extensions. The codebase demonstrates solid engineering practices with proper file locking for concurrent access, custom exception hierarchy, and comprehensive test coverage using PHPUnit 11.0. The query builder follows the builder pattern with method chaining. Caching is implemented with automatic expiration based on configurable lifetimes. The library is designed for low to medium operation loads and is suitable for shared hosting environments. Some deprecated methods are marked for removal in version 3.0, indicating active maintenance and refactoring. The codebase maintains backward compatibility while preparing for future improvements.
SuperCoder is a local-first, open-source AI coding agent with a desktop application (Tauri + Rust + React) and a suite of backend services. The core agent (Rust crate) provides an LLM-driven loop with tool execution (file editing, bash, git, code search), subagent spawning, and an 'Auto' mode where an orchestrator LLM generates plans executed by worker agents. The desktop app offers a rich UI for agent interaction, diff review, file exploration, and permission management. A separate Go-based 'Context Engine' service indexes codebases into vector (Qdrant), graph (FalkorDB), and text stores, enabling semantic code search, dependency analysis, and automated PR review with risk scoring. The repository also includes a legacy v1 backend (Go) with workflow executors for Django/Flask/Next.js code generation and a workspace service for managing isolated development environments. While primarily an application, the context engine introduces data/research elements through its indexing pipelines, retrieval strategies, and code review analytics.
This is a production-oriented full-stack SaaS starter kit (not a data/research project). It is a monorepo template pairing a Next.js web app (landing page, auth flow, account dashboard, marketing sections) with a Flutter cross-platform app (iOS/Android/macOS/Windows/Linux/web) on top of a shared Supabase backend. The backend is a Postgres schema (users, customers, products, prices, subscriptions, invoices) protected by row-level security, plus Deno edge functions that orchestrate Stripe Checkout sessions and process Stripe webhooks. PostHog handles analytics on both frontends, Loops.so handles transactional email, and an optional Monero cryptocurrency payment variant can be toggled in via patch scripts, giving the template two billing backends.
This repository is the W3C WebTransport specification and its supporting reference materials. It is not a deployed application but a standards-track document repository with interactive sample code. The core deliverable is index.bs, a Bikeshed/WebIDL specification defining the WebTransport API for low-latency, bidirectional, client-server communication over QUIC/HTTP/3, with fallback to HTTP/2. The spec covers reliable streams, unreliable datagrams, send ordering/groups, atomic writes, connection stats, and security/privacy considerations. In practice, this repo defines an evolving browser API, not a runtime service. The repository also contains functional sample implementations: a basic JavaScript echo client and a more advanced WebCodecs echo sample that streams real-time video over WebTransport using a dedicated worker. The Python reference servers (samples/echo/py-server) implement a WebTransport-over-HTTP/3 endpoint using aioquic, handling CONNECT handshakes, bidirectional streams, unidirectional streams, and datagrams. These samples are the only executable code and serve as demonstration/test harnesses rather than production components. As a spec repository, the codebase is maintained and receives regular updates, but it is deliberately experimental. The API surface and underlying IETF drafts are still evolving, sample code references hardcoded public endpoints, and some bundled ReSpec infrastructure appears dated. The specification itself is carefully written and follows W3C conventions, but the repository's value is primarily as a normative reference and a source of patterns for WebTransport implementations.
The Codex Startup Pressure Test Skill is an npm package that installs a specialized skill for the OpenAI Codex AI assistant. Once installed, the skill enables users to pressure-test startup ideas by invoking it within Codex prompts, which then generates a structured evaluation covering verdict, scorecard, core assumptions, flaws, and actionable steps for validation. The architecture consists of a skill directory containing markdown-based instructions (SKILL.md and playbooks.md) that define the skill's behavior, an interface configuration for OpenAI (agents/openai.yaml), and an installer script (scripts/install.js) that handles deployment to the user's Codex skills directory. The skill relies on Codex's natural language processing to perform the actual analysis, with the repository providing the domain-specific guidance and framing. Key strengths include the well-documented skill framework that captures proven startup evaluation methodologies and the reusable installer script, which demonstrates solid CLI engineering practices with argument parsing, path handling, and recursive directory copying. The project is actively maintained and shows no signs of technical debt, depending only on Node.js built-in modules.
GENie is a mature command-line project generator descended from Premake 4. It embeds Lua 5.3.0 as its scripting engine, allowing users to declaratively define solutions, projects, configurations, dependencies, toolchains, and custom actions in Lua scripts. The tool then generates native project/build files for Visual Studio (2010 through 2026), Xcode (8 through 15), GNU Make, Ninja, CMake, and JSON compilation databases. It is self-hosting: the repository's own build scripts are GENie Lua scripts, and the compiled binary is used by projects such as bgfx, MAME, and SoLoud.
Cali is a TypeScript-based CLI application designed for React Native and Expo development teams. It functions as an AI-powered orchestration layer that automates mobile quality assurance, code review, and performance analysis. The system operates by ingesting repository context (PR data, mobile artifacts) and executing structured agent loops that interact with platform-specific tools (Android/iOS SDKs) via the Vercel AI SDK. It supports both local execution and CI environments (GitHub Actions, EAS), generating structured reports in JSON and Markdown formats. Architecturally, it follows a monorepo pattern with distinct packages for the core CLI (packages/cali) and platform-specific tool wrappers (packages/tools). The core logic relies on a role-based command structure where specific tasks (QA, Review, Dev) are delegated to specialized agent roles. Data flow is deterministic, moving from context resolution through tool execution to report publishing, ensuring consistent behavior across different environments. The tool distinguishes itself by managing complex mobile development contexts, such as artifact parsing (APK/IPA) and device management, which are typically brittle in automated workflows. It integrates skill discovery for AI agents and supports multiple output publishers (local file, Vercel Blob). While it solves a specific niche problem effectively, it introduces dependencies on external binaries and rapid-versioning AI SDKs that require careful maintenance.
Kiwi IRC is a web-based IRC client built with Vue.js 2.x that enables users to connect to IRC networks through a browser interface. The application features a modular architecture with separate concerns for state management, IRC protocol handling, UI components, and plugin extensibility. Key functionalities include network/channel management, real-time messaging, theming, internationalization, bouncer/ZNC support, and a plugin system for UI extensions. The codebase demonstrates solid engineering practices with clear separation of concerns, though it carries technical debt from Vue 2.x dependency and IE11 support requirements.
ClusterSSH is a Perl-based cluster administration tool that provides a graphical console (using Tk) to manage multiple SSH (or other protocol) sessions simultaneously. It allows users to define clusters via configuration files, expand hostnames using shell-style ranges, and replicate keystrokes from a master console to all connected terminal windows. The architecture is monolithic, centered around the App::ClusterSSH module, with distinct sub-modules handling configuration, cluster resolution, host parsing, and window management via X11::Protocol. It relies heavily on the X11 protocol for event injection into child xterm processes, making it tightly coupled to X11 environments but highly effective for its specific use case of synchronized cluster management.
WanAndroid is a polished, feature-rich Android client for the WanAndroid platform (wanandroid.com), a Chinese community for Android developers. The application provides comprehensive browsing of articles, projects, WeChat articles, knowledge trees, navigation, Q&A, book tutorials, and daily news aggregation from multiple Chinese sources. It implements a classic MVP architecture with a modular project structure (app, basic/core, basic/ui, basic/utils, basic/l10n, component/ad). Key entry points include SplashActivity and MainActivity (hosting a bottom-tab fragment container). The system heavily leverages OkHttp/RxHttp for network requests to the WanAndroid REST API, DiskLruCache for offline caching, Room for local persistence (read-later and read-history), and EventBus for cross-component events. Beyond vanilla browsing, it features a custom WebView subsystem (WebInstance, WebContainer) with resource interception, offline HTML/ CSS caching, a reading mode using readability4j and Jsoup, and JavaScript injection for image clicks. It also includes text-to-speech (TTS) via Android TTS engine with AI-powered summarization, biometric quick login, QR code scanning, card/article sharing, a coin/ranking gamification system, and in-app updates. External dependencies include Google AdMob for ads, optional AI provider APIs (e.g., DeepSeek), and the WanAndroid server endpoints. The codebase is a mix of Java and Kotlin, with several reusable custom UI components like BottomDrawerLayout, ImagePreviewView, CollectView, and custom pull-to-refresh headers with Chinese poetry.
This repository is a comprehensive collection of examples, tutorials, and applications demonstrating how to use LanceDB (a vector database) for various AI/ML applications. It showcases patterns for retrieval-augmented generation (RAG), multimodal search, chatbots, recommendation systems, and AI agents. The repository contains both Python and JavaScript/TypeScript implementations, with many examples featuring web interfaces using Streamlit, Gradio, or React. While it serves as a valuable resource for learning LanceDB integration patterns, the quality varies across examples, and some content is marked as archived.
This repository is a PHP library for creating Apple Wallet passes (.pkpass files) and related functionality. It provides classes to generate, sign, and package passes according to Apple's Wallet specifications, including support for boarding passes, store cards, event tickets, and financial orders. The library handles certificate-based signing, file inclusion, localization, and pass creation through a clean object-oriented interface. The architecture centers around the PKPass class which implements the core pass creation logic, including manifest generation, signature creation using OpenSSL, and ZIP packaging. FinanceOrder extends PKPass for financial transaction orders with order-specific constants and SHA-256 hashing. PKPassBundle enables combining multiple passes into a single .pkpasses file for bulk distribution. The Push class handles Apple Push Notification Service (APNS) integration for sending pass updates to devices. Key features include flexible data input (arrays or JSON strings), file management (local, remote, and string content), localization support, and proper error handling through custom exceptions. The library requires PHP 7.0+ with ZIP, JSON, and OpenSSL extensions, and includes comprehensive testing via PHPUnit.
FairwindsOps/rbac-lookup is a CLI tool written in Go for reverse-looking up Kubernetes Role-Based Access Control (RBAC) bindings. Given a user, service account, or group name, it queries a cluster's RoleBindings and ClusterRoleBindings and displays the associated roles and scope (namespace or cluster-wide). It also provides optional GKE integration that fetches Google Cloud IAM policies and maps IAM roles (e.g., container.admin, viewer) to display alongside Kubernetes RBAC roles. The architecture is a monolithic Cobra-based CLI with a lookup package that encapsulates the logic for loading role bindings from the Kubernetes API and optionally from the Google Cloud Resource Manager API. The code is well-structured, idiomatic Go with comprehensive unit tests and e2e tests across multiple Kubernetes versions. The key data structures (rbacSubject, simpleRole) are cleanly separated and could be reused in other Kubernetes RBAC analysis tools.
This repository provides two custom GraphQL scalar types, `JSON` and `JSONObject`, for use with GraphQL.js. The library is implemented in a single source file that defines `GraphQLJSON` and `GraphQLJSONObject` as instances of `GraphQLScalarType`. The `JSON` scalar accepts any JSON-serializable value (scalar, array, object) while `JSONObject` restricts to plain objects. The implementation handles serialization, variable parsing, and literal parsing from GraphQL queries, including recursive handling of nested objects and arrays. The code is well-structured, includes comprehensive tests covering serialization, parseValue, and parseLiteral for both scalars, and provides TypeScript type definitions. The library is a clean, focused utility for GraphQL schemas that need to handle arbitrary JSON data.
This repository provides a Python CLI tool and Makefile pipeline to scrape all essays from Paul Graham's website (paulgraham.com), convert them to Markdown, and produce an EPUB ebook. The core logic resides in a single script (`graham.py`) that uses `requests`, `BeautifulSoup`, `html2text`, and `htmldate` to download, parse, and date-stamp each essay. A `Makefile` orchestrates the full build: creating a virtual environment, fetching essays, merging them with `pandoc`, and generating the final EPUB with a custom CSS and an iBooks dark-mode patch. The CI workflow (GitHub Actions) runs daily, detects new essays by comparing article counts, and automatically creates a release with the updated EPUB and metadata CSV. The architecture is straightforward—no web server, database, or tests—but the pipeline is robust and well-documented for its single purpose. While the scraper is tightly coupled to Paul Graham's site structure, several components (the iBooks patcher, the footnote conversion function, and the EPUB stylesheet) are cleanly isolated and reusable in other EPUB generation projects.
This repository is a serverless web application that serves as a playground and API proxy for Google's Gemini Multimodal Live API. It provides a client-side interface for real-time text, audio, video, and screen-sharing interactions with the Gemini model. Crucially, it includes a backend proxy layer (deployable on Cloudflare Workers or Deno) that converts the native Gemini WebSocket/REST API into an OpenAI-compatible format, enabling integration with third-party clients like ChatBox or Cursor. The architecture is split between a static frontend (vanilla JS) and a lightweight serverless proxy that handles authentication, protocol translation, and streaming logic.
AutoPy is a cross-platform GUI automation library implemented in Rust and exposed to Python through PyO3. It provides programmatic control of the mouse and keyboard, screen capture, bitmap pixel inspection, and color detection. The library abstracts over Windows, macOS, and X11 backends, so the same Python API works across desktop platforms. It is distributed as a Python extension module built with maturin/setuptools-rust and is also usable as a Rust crate.
This repository is the source for official Firebase Extensions: a Lerna-monorepo of self-contained, event-driven Cloud Functions applications, each packaged with an extension.yaml manifest for installation into Firebase projects. In production the extensions react to Firestore, Realtime Database, Cloud Storage, Auth, Pub/Sub, and scheduled triggers to sync data to BigQuery, send email through SMTP/SendGrid, resize and moderate images, translate document fields, shorten URLs, limit RTDB child nodes, delete user data across Google services, and maintain distributed counters. The firestore-bigquery-export extension is the most data-heavy component and includes a reusable npm package, CLI import tooling, schema-view generators, partitioning/clustering logic, and materialized-view SQL, making the repo a hybrid of serverless application code and data-pipeline engineering. Each extension follows a consistent architecture: a typed env-var config module, structured logging, Eventarc event recording, and a functions/src/index.ts Cloud Functions entry point. The BigQuery exporter is built around a published @firebaseextensions/firestore-bigquery-change-tracker library that handles dataset/table initialization, Firestore-change streaming, schema-lag retries, failed-transaction backup, and latest-snapshot query generation. Companion CLIs support backfilling existing Firestore collections into BigQuery and generating typed BigQuery views, including AI-assisted schema inference via Genkit/Gemini. A distributed counter extension additionally ships web, Android, iOS, Dart, and Node client libraries. The repository is professionally tested with unit, emulator, and gated integration/e2e suites, but it is in a transitional state: the official Firebase Extensions platform is scheduled to shut down in 2027, firestore-bigquery-export is already deprecated in favor of a newer function-kit package, and the codebase mixes firebase-functions v1 and v2, legacy and modern BigQuery SQL paths, and old client toolchains. The overall architecture remains solid and many internal patterns are reuse-worthy, but the deprecation horizon and inconsistent modernization limit its long-term value as a reference implementation.