This is a boilerplate project for mobile app and browser test automation using Appium and WebdriverIO v9. It provides a comprehensive set of example tests, page/screen objects, reusable helpers, and configuration files for running tests locally or on cloud providers (Sauce Labs, BrowserStack, TestingBot, LambdaTest). The codebase demonstrates cross-platform testing patterns for iOS and Android, including biometric login, deep link navigation, drag-and-drop, swiping, form interactions, and WebView handling. It is well-structured with TypeScript, async/await, and the Page Object Model. The project is actively maintained with recent commits and up-to-date dependencies, making it a solid starting point for teams implementing mobile automation.
This repository is a comprehensively governed, production-grade library of 115+ prompt templates, meta-prompt generators, workshop guides, and structured routines for AI-assisted product management. It is not a deployed software application but rather a content methodology repository with application-like engineering discipline: standalone prompt contracts, coupling levels, CI-validated metadata, deterministic catalog generation, and an explicit coupling remediation plan. The library covers the full product management lifecycle—discovery, strategy, requirements, competitive intelligence, end-of-life, storytelling, and team facilitation—using three defined interaction modes (facilitation, co-construction, autonomous investigation). Notable sub-collections include an eight-discipline market intelligence framework (OSINT, FININT, GEOINT, etc.) with an all-source fusion prompt, a complete product sunset (EOL) workflow, and a TAM-SAM-SOM market sizing Langflow pipeline. The repo exhibits hybrid character: while primarily a content asset, it includes reusable Python scripts for validation and catalog generation, a GitHub Actions CI pipeline, and follows software engineering best practices such as versioning, changelogs, and architectural decision records.
sqlalchemy_mptt is a Python library that provides SQLAlchemy mixins for implementing Modified Preorder Tree Traversal (MPTT) with SQLAlchemy models. It automatically maintains tree structure through SQLAlchemy event listeners, handling insert, update, and delete operations while preserving tree integrity. The library supports multi-tree scenarios, various primary key types, and provides methods for tree traversal, drilldown operations, and path-to-root queries. The architecture centers around the BaseNestedSets mixin class that adds tree-specific columns and methods to SQLAlchemy models, complemented by a TreesManager that handles SQLAlchemy events to automatically maintain lft, rgt, level, and tree_id attributes. The library demonstrates strong engineering practices with a compatibility layer for SQLAlchemy versions, comprehensive test suite, and active maintenance with recent support for SQLAlchemy 2.0 and modern Python versions.
MailCrab is an email test server written in Rust, inspired by MailHog and MailCatcher. It provides an accept-all SMTP server and a web interface to view and inspect incoming emails.
This is a Prometheus exporter for NATS server monitoring. It polls NATS server HTTP monitoring endpoints (varz, connz, subz, routez, healthz, jsz, etc.) and exposes metrics in Prometheus format. The architecture is a standalone binary with an embeddable library API. Key entry points are the CLI (main.go) and the exporter.NewExporter function. Data flow: on each scrape, collectors make HTTP requests to NATS monitoring endpoints, parse JSON responses, and convert them to Prometheus gauge metrics. The exporter supports TLS, basic auth, custom metric prefixes, and multiple NATS servers (though one per exporter is recommended). It includes pre-built Grafana dashboards for both NATS core and JetStream metrics. The codebase is well-structured with separate packages for collectors, exporter, and test utilities. It uses reflection-based metric extraction for simple endpoints and custom collectors for complex ones like JetStream, connections, and gateways. The project is actively maintained with recent commits and modern dependencies.
SPAG4D is a production-grade tool that converts 360° equirectangular panoramic photos into explorable 3D Gaussian Splat (3DGS) scenes. It integrates multiple depth estimation backends (DA360, DAP, PaGeR, SHARP, UniSHARP) to generate depth maps from a single panorama, then projects the points into standard 3DGS PLY format. The system provides a CLI, a FastAPI web server with a JavaScript frontend, and a Python API for programmatic use. Beyond the core conversion, it includes optional refinement pipelines to fill holes and improve scene quality: OmniRoam (WSL2-based video generation and distillation), ArtiFixer3D (Docker-based diffusion refinement), and a lighter geometric refinement pipeline using depth alignment and voxel aggregation. The architecture is modular with pluggable generators, comprehensive configuration dataclasses, and provenance tracking. While the tool is primarily an application, it leans heavily on research-grade depth models and refinement techniques, giving it a hybrid character. The codebase is well-structured with clear separation of concerns, reusable utilities (spherical projection, depth blending, scene filtering, geometric alignment), and extensive tests. It is actively maintained with recent commits, though it carries complexity from multiple backends and platform-specific dependencies (WSL2, Docker, CUDA).
This repository implements MiniMind-3o, a small-scale Omni model (text/audio/image input, text/streaming audio output) designed for educational and research purposes. The system uses a Thinker–Talker dual-path architecture: a language model (Thinker) processes multimodal input and produces text tokens, which are then fed to a Talker module that generates audio codes using the Mimi codec and decodes to PCM audio. It supports voice cloning via reference audio, scheduled sampling during training, and staged training (T2A → A2A → I2T). Multiple inference interfaces are provided: a CLI (`eval_omni.py`), a Gradio web demo, and a real-time WebSocket-based WebUI with VAD and barge-in capability. The codebase is well-structured with clear separation of concerns, and the Thinker–Talker decoupling pattern is a notable architectural contribution. While primarily an application, it includes research-oriented components such as ablation studies and a technical report, making it a hybrid project with a strong application focus.
This repository is a React Native library that wraps Radar's native iOS and Android SDKs to provide geofencing, location tracking, trip tracking, geocoding, search, context, route/matrix, places, beacons, fraud verification, and in-app messaging capabilities. It exposes a JavaScript API (Radar.initialize, Radar.autocomplete, etc.) and optional UI components (Map, Autocomplete) for use in React Native applications. The architecture consists of a TypeScript/JavaScript layer that communicates with native code via React Native's bridge (old and new architectures), with vendored iOS xcframeworks and Android Java modules. The library handles native setup automation (AppDelegate injection, Podfile modification) through an Expo config plugin, and includes version sync scripts to keep SDK versions consistent across platforms. It supports both iOS and Android, with optional fraud and motion SDK extensions. The example app demonstrates usage with MapLibre for map display. The codebase is well-structured with CI workflows, tests for the Expo config plugin, and careful version management, though it carries binary xcframework artifacts and dual architecture support that increase maintenance surface.
MiroTalk P2P is a self-hosted, open-source WebRTC video conferencing application that enables real-time peer-to-peer video calls, audio calls, screen sharing, chat, whiteboard collaboration, file sharing, and recording. The architecture consists of a Node.js/Express server with Socket.IO for signaling and a REST API (v1) for programmatic meeting management, token generation, and statistics. The client is a single-page application with modular JavaScript files handling UI components, media processing, accessibility, and integrations. Key features include end-to-end encrypted media (SRTP/DTLS), noise suppression via RNNoise AudioWorklet, live captions (Web Speech API and server-side Whisper transcription), ChatGPT integration, OIDC authentication, JWT-based API security, and an embeddable support widget. The system is designed for privacy: no persistent storage of signaling data, chat, or media; recordings stay in the browser as Blobs. Deployment options include Docker, Kubernetes, and bare-metal, with support for CoTURN TURN servers, ngrok tunneling, and email alerts via Nodemailer. The codebase is well-structured with separate modules for security (XSS sanitization, input validation, host protection), logging, and integration helpers, though the main server.js is monolithic (~2000 lines) and the client-side CSS is large (~5000 lines combined).
RedisInsight is a full-stack graphical user interface for managing and interacting with Redis databases. It is built as an Electron desktop application with a React frontend (utilizing styled-components and a custom component library) and a NestJS backend that communicates with Redis instances. The application covers a wide range of Redis features: key-value browser with support for all data types (strings, hashes, lists, sets, sorted sets, streams, JSON, arrays, vector sets), a workbench with a Monaco-based query editor, CLI, pub/sub, slow log, profiler, database analysis with optimization recommendations, cloud integration (Redis Cloud, Azure Cache, Redis Enterprise), Redis Data Integration (RDI) pipeline management, and an AI assistant. The architecture is modular with clear separation of concerns, using repository and strategy patterns extensively. The codebase includes comprehensive CI/CD, end-to-end Playwright tests, and a plugin system for custom visualizations.
Proto.Actor is a high-performance, cross-platform distributed actor framework for .NET. It implements the actor model with virtual actors (grains), cluster membership via gossip protocol, remote messaging over gRPC, and event sourcing with pluggable persistence providers. The architecture is modular: the core actor runtime (Proto.Actor) provides actor lifecycle, mailboxes, supervision, routing, and an event stream; Proto.Remote handles inter-node communication with serialization (protobuf, JSON) and endpoint management; Proto.Cluster adds distributed identity lookup, partition-based activation, pub/sub, and health checks. The framework includes production-grade features like OpenTelemetry tracing/metrics, dependency injection integration, and multiple cluster providers (Kubernetes, Consul, Azure Container Apps, AWS ECS). Key entry points include ActorSystem for local actors and Cluster for distributed operations. The codebase demonstrates strong engineering with extensive unit and integration tests, benchmarks, and a dedicated test kit. Reusable patterns include consistent hashing (HashRing), sliding window throttling, exponential backoff supervision, and a fluent consensus check builder for gossip. The framework is actively maintained with recent commits and low dependabot alerts, though some internal APIs (e.g., obsolete loggers, CouchbaseNetClient 2.7.x) show moderate technical drift. Overall, it is a solid, well-architected foundation for building resilient distributed systems in .NET.
QtKeychain is a cross-platform Qt library for securely storing passwords and secrets using platform-native keychain services. It provides a unified QKeychain::Job API (ReadPasswordJob, WritePasswordJob, DeletePasswordJob) that delegates to the appropriate backend: macOS/iOS Keychain, Windows Credential Store (or CryptProtectData), Linux via KWallet, libsecret, or GNOME Keyring, Android Keystore, Haiku's KeyStore, and a WebAssembly bridge using the Credential Management API. The library is primarily a thin abstraction layer with clean separation of platform concerns, an internal job queue for serialization, and a fallback mechanism to store data in plaintext via QSettings when no secure backend is available. It supports Qt 5 and Qt 6, requires C++11/17, and bundles translation files for several languages.
Spice is a Zig library for low-overhead parallelism using heartbeat scheduling. It provides a fork/join model where workers maintain local work queues and a heartbeat thread periodically signals workers to offload work to others. The design avoids common work-stealing pitfalls: dynamic dispatch is minimized by using static calls for local work, queues are truly local (no atomics for push/pop in common case), and spinning is eliminated by using blocking waits. The library is demonstrated with a binary tree sum benchmark showing sub-nanosecond overhead. While primarily a research project with noted limitations (lack of tests, no array support), the implementation exhibits high craftsmanship in its concurrency primitives and performance optimizations.
napari-chatgpt (Omega) is an LLM-powered autonomous agent designed as a napari plugin for interactive image analysis. It enables users to interact with the napari viewer via natural language through a chat interface, either embedded in napari or via a web-based UI. The system processes user commands by leveraging LLMs (via LiteMind) to select and execute appropriate tools for tasks such as image loading, segmentation, denoising, widget creation, viewer control, web search, and code execution. The architecture centers around a plugin-contributed dock widget that launches a chat interface, which communicates with a FastAPI/WebSocket backend. The backend hosts the Omega agent, which uses a modular tool system where each tool (e.g., for file operations, segmentation, or web requests) inherits from a base class and is responsible for executing specific actions. The agent can iteratively refine its actions through dialogue, enabling complex workflows like 'segment nuclei and show measurement statistics'. Key external dependencies include napari (>=0.5), LiteMind, LLM provider libraries (OpenAI, Anthropic, Google), FastAPI, Qt bindings, and scientific libraries like scikit-image, Cellpose, and StarDist.
Remindian is a macOS menu bar application that synchronizes tasks between Obsidian (as the source of truth) and various task management systems including Apple Reminders, Things 3, Todoist, TickTick, Asana, Linear, and Calendar Feed. The app allows users to configure multiple sync profiles, each connecting a source (Obsidian Vault, TaskNotes, or Generic Markdown) to a destination task service. It runs in the background with manual or scheduled synchronization, provides UI for configuration and monitoring, and includes safety features like automatic backups before file modifications, audit logging, and conflict resolution where Obsidian always wins as the source of truth. The architecture follows a layered pattern with SwiftUI for the presentation layer, a service layer for platform-specific integrations, a model layer for data structures, and protocol-based abstractions (TaskSource/TaskDestination) that enable pluggable implementations. The SyncManager acts as the central coordinator, while the SyncEngine orchestrates the synchronization process. Key features include bidirectional sync with configurable directions, duplicate detection, natural language task entry, and extensive customization options for field mapping and filtering. The application demonstrates strong engineering practices with a comprehensive test suite, careful attention to data integrity through surgical file edits and backup systems, and thoughtful handling of platform-specific integrations. While deeply integrated with macOS and specific task services, it maintains clean separation of concerns through its protocol-oriented design, making core components potentially reusable in other synchronization contexts.
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.
Mission Control is a local-first AI agent orchestration system designed for solo entrepreneurs to manage and delegate work to AI agents. It combines task management (Eisenhower matrix, Kanban board), goal tracking, project oversight, and autonomous agent execution with built-in safety controls. The system features a Field Ops subsystem for executing real-world actions via integrations with services like Twitter, Ethereum, and Reddit, complete with approval workflows, spend limits, and encrypted credential storage. An autonomous daemon handles background task execution, while all data is stored as JSON files to ensure user control and privacy. Built with Next.js 15, React, and TypeScript, it emphasizes security, error resilience, and agent-human communication through inbox and decision systems.
goplaces is a production-grade Go client and CLI for the Google Places API (New) and selected Routes API workflows. It provides typed request/response structs, deterministic field masks for cost control, context support, and pluggable HTTP. The CLI offers eight commands (search, nearby, autocomplete, details, photo, resolve, route, directions) with both human-readable and JSON output. The repository includes an extensive release pipeline with code signing, notarization, reproducible builds, and Homebrew distribution. The codebase is well-structured with clear separation between CLI rendering, API client logic, and validation. It demonstrates strong engineering practices: high test coverage (≥90%), linting, vulnerability scanning, and hardened release scripts with pinned tool versions and multi-phase verification. The project is actively maintained with frequent releases and comprehensive documentation.
ccNexus is a desktop application (built with Wails v2, Go backend + web frontend) and a headless server that acts as a smart proxy for multiple AI API endpoints, including Claude, OpenAI Chat, OpenAI Responses, and Gemini. It manages endpoint rotation with automatic failover, credential token pools (API keys, access tokens, refresh tokens), and real-time format conversion between the different API protocols. The system provides a full-featured GUI for managing endpoints, viewing usage statistics, configuring backup/restore (WebDAV, local, S3), launching Claude Code or Codex CLI terminals, and applying visual themes. A separate web UI is available for headless deployments via Docker. The architecture follows a layered design: a proxy layer handles request routing, authentication, and streaming response transformation; a transformer layer converts between API formats using a registry of converters; a storage layer persists endpoints, credentials, and stats in SQLite; and a service layer orchestrates higher-level operations like backup, updates, and terminal launching. The codebase demonstrates strong engineering practices including thread-safe configuration, adapter patterns for storage abstraction, SSE for real-time stats, and comprehensive contract tests. Notable features include zero-cost endpoint testing, incremental stats updates, and a credential lifecycle management system with rate limit tracking and automatic cooldown. While primarily an application, ccNexus includes some data-oriented components such as token counting, usage statistics aggregation, and credential rate limit parsing. However, these serve the operational needs of the proxy rather than constituting a data research pipeline. The project is actively maintained with a responsive issue tracker and regular releases.
enject is a security-focused CLI tool that prevents AI agents and other processes from reading secrets out of `.env` files. It stores secrets in an encrypted local store (AES-256-GCM with Argon2id key derivation) and injects them into subprocess environments at runtime. The `.env` file on disk contains only `en://` symbolic references, never plaintext values. The tool provides commands to initialize a store, add/update/list/delete secrets, import a plaintext `.env` file (encrypting all values and rewriting it as a template), rotate the master password, and run a subprocess with resolved environment variables. The architecture is a single Rust binary with a clean `Store` trait abstraction separating the encryption backend from command logic. The codebase demonstrates strong security practices: secrets never touch disk as plaintext, nonces are freshly generated on every write, key material is zeroized immediately after use, and unresolved references cause hard errors. It includes comprehensive unit tests and a CI pipeline with linting, formatting, and security auditing.