Ralph Wiggum for Cursor is an implementation of Geoffrey Huntley's Ralph Wiggum technique for autonomous AI development. It manages LLM context like memory by tracking token usage and rotating to fresh agent contexts when needed, persisting state in files and git. The system provides automated iteration loops with features like gutter detection, rate limit handling, task progress tracking via checkboxes, and support for both sequential and parallel execution modes. Key components include a sophisticated stream parser for real-time token and error monitoring, a YAML-backed task parser with caching, and retry logic with exponential backoff.
Sysdig is a mature, open-source system monitoring and troubleshooting CLI tool that instruments the Linux kernel to capture system calls and other OS events. It provides a rich curses-based interactive UI (csysdig) and an extensible Lua chisel framework for real-time analysis of CPU, I/O, network, security, and container metrics. The codebase is predominantly C++ with a Lua scripting layer, and includes a comprehensive plugin system for alternative event sources (e.g., gVisor, custom plugins). It also ships a large set of kernel driver build configurations (driverkit) for supporting many Linux distributions and kernel versions. The architecture is a classic CLI application with a modular design: libsinsp for event introspection, chisels for analysis, and a curses UI for visualization. The project is actively maintained by the Sysdig team and the Falco community, with regular commits and CI pipelines.
Androidify is a production Android application that generates personalized Android bot avatars using AI. Users capture a photo or enter a text prompt; the app processes it through on-device (Gemini Nano) or cloud (Gemini/Imagen via Firebase) AI to create a stylized bot image. The result can be customized with backgrounds and sizes, exported as an image, or sent as a watch face to Wear OS smartwatches. The app also includes a companion Wear OS module for watch face onboarding and transfer. The architecture follows an MVVM/Clean Architecture pattern with Kotlin and Jetpack Compose UI, using Hilt for dependency injection. It is modularly organized into core modules (network, theme, util, xr), feature modules (home, camera, creation, results, customize), data repositories, and a separate wear module. Custom Gradle plugins standardize Android library and application build configuration, including ProGuard, signing, and SBOM generation. Key entry points: AndroidifyApplication.kt (Hilt entry) and MainActivity.kt for the phone app; MainActivity.kt in the wear module for the watch companion. Navigation flows through MainNavigation.kt: Home → Camera → Creation → Results → CustomizeExport. External dependencies include Firebase (App Check, Remote Config, AI Logic SDK, Crashlytics), Google Gemini and Imagen APIs, ML Kit for on-device segmentation, and CameraX for camera integration. Primary data flows: User input (image or text) → CameraViewModel or CreationViewModel → TextGenerationRepository or ImageGenerationRepository (with fallback between on-device and cloud AI) → ResultsScreen with flippable card → CustomizeExportViewModel for background/size tools → optionally, WatchFaceInstallationRepository and WearAssetTransmitter for watch face push. Remote Config provides feature flags and AI prompts, while on-device segmentation (ML Kit) handles background removal.
This repository contains a mentions plugin for the Lexical text editor, along with a Next.js demo application. The plugin provides advanced mentions functionality including customizable triggers, multiple trigger support, automatic spacing, async query functions, customizable styling, and programmatic manipulation of mentions. The architecture consists of a core plugin implementation in the 'plugin' directory and a demonstration application in the 'www' directory. The plugin follows a modular design with separate concerns for UI components, state management, text processing, and editor integration. Key features include mention detection via regex, custom node implementation for Lexical, and hooks for managing asynchronous data fetching with proper loading states.
OpenCTI is an open-source cyber threat intelligence platform that ingests, manages, and analyzes threat data using the STIX 2.0/2.1 standard. The system is a monorepo containing a Node.js/TypeScript GraphQL backend (opencti-graphql), a React/Relay frontend (opencti-front), a Python client library (client-python), and a Python worker service (opencti-worker). The backend uses Elasticsearch/OpenSearch as its primary data store, Redis for caching and pub/sub, RabbitMQ for connector queues, and PostgreSQL for migrations. The frontend provides full CRUD UIs, dashboards, workspaces, playbook automation, and workflow management. Key entry points include the GraphQL API (resolvers per entity type), the frontend React app with Relay data fetching, and the Python client for programmatic access. Data flows involve ingestion via CSV/JSON/TAXII/RSS feeds, manual creation, connector enrichment, and inference rules that automatically derive relationships. External dependencies include Elasticsearch, Redis, RabbitMQ, MinIO/S3 for file storage, and optional AI services. The platform supports enterprise features (playbooks, PIR, XTM Hub) gated by license checks.
go-instrument is a CLI tool that automatically instruments Go source files with OpenTelemetry trace spans. It parses Go AST, identifies functions that accept a `context.Context` parameter, and inserts span creation, defer, and optional error recording statements. It handles various edge cases: anonymous functions, build constraints (ignore/exclude), generated files, custom context/error parameter names, already-instrumented functions, and preserves original line numbers for panic stack traces via compiler directives. The tool is implemented as a reusable library with a clear separation between the generic AST processing engine (`processor` package) and the specific instrumentation strategy (`instrument` package), allowing custom instrumenters. The CLI frontend is minimal; the core logic is in the `processor` and `instrument` packages and is cleanly abstracted via an `Instrumenter` interface. The codebase is well-tested, includes fuzz testing, and uses current Go tooling.
This repository provides a SQLAlchemy dialect for DuckDB, enabling DuckDB to be used as a database backend within SQLAlchemy's ORM and Core APIs. It maps DuckDB's type system to SQLAlchemy types, handles connection management (including in-memory and file-based databases), supports reflection (schema introspection), and integrates with DuckDB extensions. The dialect is built on top of the PostgreSQL psycopg2 dialect, customizing it for DuckDB's capabilities and limitations. The source code is well-structured, extensively tested, and actively maintained, with support for DuckDB versions 0.5.0 through 1.2.2 and SQLAlchemy 1.3 through 2.0.35.
Birdie is a snapshot testing library for the Gleam programming language. It provides a `snap` function to capture and compare test outputs against stored snapshots, and a CLI interface to review, accept, reject, and manage snapshots. The architecture separates concerns into modules for snapshot handling, CLI parsing, diagnostic formatting, diff computation, and project metadata. Key entry points are the `snap` function for writing tests and the `main` function for the CLI tool. The system relies on Gleam standard library and several community packages for argument parsing, file operations, ANSI styling, and source code analysis via the `glance` library. Data flows involve test execution creating `.new` snapshot files, CLI review moving them to `.accepted` or deleting them, and stale snapshot detection via a reference file tracking which snapshots were used during test runs.
vkbottle is an asynchronous Python framework for building VK (VKontakte) bots and interacting with the VK API. It provides both high-level abstractions (Bot, User, labelers, rules, middlewares, state dispensers) and low-level API clients with pluggable request/response validation, token rotation, and error handling. The framework is fully async, built on asyncio and aiohttp, and supports long polling, callback API, and dual mode (simultaneous polling and callback). It includes extensive tooling for keyboards, templates, uploaders, markdown-to-VK-format conversion, VKScript generation, event deduplication, and a waiter machine for awaiting future events. The architecture is modular with abstract base classes for nearly every component, enabling custom implementations. The codebase is well-structured with clear separation of concerns, extensive test coverage, and CI/CD pipelines. Deprecated components (LoopWrapper, Blueprints) are clearly marked, and the library is actively maintained with a mature version 4.11.0.
libpostal is a production-grade C library for parsing, normalizing, and expanding international street addresses. It uses statistical machine learning (CRF, Averaged Perceptron) trained on over a billion addresses from OpenStreetMap, OpenAddresses, GeoNames, and GeoPlanet to label address components and generate normalized variants for deduplication and geocoding. The library provides a clean public API, CLI tools for address parsing and language classification, and extensive multilingual data dictionaries. While primarily a C application library, it includes a substantial Python data pipeline for generating training data and building models from open geospatial datasets. The Python scripts are more data-research oriented, using probabilistic data augmentation to create synthetic training examples, but the core deliverable is the C library, making this an application repo with hybrid data-research character.
Routify (@roxi/routify) is a file‑based routing framework for Svelte applications. It provides a build‑time plugin system that parses a directory structure (files, `_module`, `_reset`, `[param]`, `[...spread]`) into a route tree, and a runtime that renders routes with support for multiple routers, decorators, inline pages, and SSR/SSG. The library integrates with Vite via a dedicated plugin and with Express for server‑side rendering. It is not a standalone application but a library published on npm, with a CLI (`routify build`, `routify create`) and a rich set of example projects demonstrating usage with SvelteKit, Tailwind, TypeScript, mobile layouts, and more. The codebase is well‑structured, with clear separation between build‑time and runtime logic, a plugin architecture, and comprehensive tests. Despite its pre‑release version (`3.0.0‑next.22`), the library is actively maintained and production‑ready for many use cases.
This is a PHP library (Composer package) for generating avatar images from a person's name or email. The core functionality extracts initials from the name and renders them as a colored circle or square with configurable fonts, colors, borders, and themes. It supports multiple output formats: base64 data URIs, PNG/JPG/WebP files, SVG markup, and Gravatar URLs. The library integrates tightly with the Laravel framework via service providers and facades, but can also be used standalone in any PHP project. The codebase demonstrates solid PHP 8.3+ practices including typed properties, traits, interfaces, and dependency injection. The architecture follows a builder pattern with method chaining. The repository also includes experimental HD avatar features (HDAvatar, ImageExport, StorageOptimization traits) that extend the core with higher resolutions, responsive sizes, and storage management, though these appear less mature and have incomplete test coverage. The initials generator (DefaultGenerator) is a well-isolated, reusable component that handles single/multi-word names, email addresses, ASCII conversion, uppercase, and RTL text.
Playwright MCP is the npm distribution package for Microsoft's Model Context Protocol server that exposes Playwright browser automation to LLM clients as MCP tools. Despite the large star count, this repository contains almost no product source: the actual MCP tool implementation (browser_click, browser_navigate, browser_snapshot, network routing, storage, vision, PDF, devtools, and testing capabilities) lives in the Playwright monorepo at packages/playwright-core/src/tools/mcp. cli.js and index.js are thin shims that re-export tools.decorateMCPCommand and tools.createConnection from playwright-core's internal bundles, and src/README.md openly states where the source is. This repo functions as the release-shipping wrapper: it pins a Playwright alpha build, rolls it forward via roll.js, regenerates README tool/config documentation from the bundled tool schemas via update-readme.js, publishes the @playwright/mcp npm package (GitHub Actions OIDC, Azure ESRP, and the MCP Registry with server.json/package.json version validation), and builds multi-arch Docker images. Classified as a pure application, not data_research.
Dexmaker is a set of libraries that enable runtime bytecode generation and mocking on Android, primarily to support Mockito test frameworks. It provides two mocking modes: a proxy-based approach (dexmaker-mockito) that generates subclasses via the Dalvik bytecode generation API, and an inline approach (dexmaker-mockito-inline) that uses a JVMTI agent to transform class bytecode at runtime, allowing mocking of final and static methods. The core module (dexmaker) offers a low-level, fluent API for constructing DEX files programmatically, including types, methods, fields, and bytecode instructions. This is complemented by a C++ library (slicer) that reads, writes, and instruments DEX files, used by the inline mock maker to inject hooks into methods. The project is deeply integrated with Android internals, using hidden APIs and native agents, and is actively maintained to keep up with Android platform changes. It serves as the primary mocking solution for Android instrumentation tests where Java bytecode-based mocks (like ByteBuddy) are not available.
Apache Seata is a distributed transaction solution for microservices, implementing AT (Automatic), TCC, Saga, and XA transaction modes. It provides a Transaction Coordinator (TC) server, client libraries for Resource Managers (RM) and Transaction Managers (TM), and supports multiple databases, serialization formats, and service discovery backends. The architecture is plugin-driven via Java SPI, with a custom EnhancedServiceLoader for loading compressors, serializers, registries, and configuration providers. The codebase includes a Netty-based RPC layer with protocol versioning (v0, v1, v2), a robust Saga state machine engine with a visual designer, and a Spring Boot-based console for cluster management and global transaction monitoring. It integrates deeply with Spring, Dubbo, gRPC, and other RPC frameworks, and offers GraalVM native-image support for server deployments. The repository is extensive with over 30 Maven modules, reflecting both its production maturity and the complexity of maintaining backward compatibility through a deprecated io.seata package layer.
The iOS Backup Machine is a self-contained backup appliance for iOS devices, designed to run on a single-board computer (Radxa Zero 3W) with a Waveshare e-Paper display and PiSugar UPS. The software provides a Flask-based web UI for configuration and monitoring, a background daemon that manages iPhone backups via libimobiledevice (idevicebackup2), remote sync via rsync over SSH with host key pinning, WireGuard VPN integration for secure remote access, and notification delivery via MQTT or webhooks. It features encrypted credential storage (AES-256-GCM), automatic backup scheduling, staleness detection, battery-aware operation, and a setup wizard. The architecture is primarily monolithic with the main daemon (iosbackupmachine.py) handling display, backup orchestration, network monitoring, and hardware integration, while separate modules handle sync management, crypto, config, and the web interface. The codebase is well-tested with unit tests covering fail-safes, resource bounds, and configuration migration, and it demonstrates strong engineering practices in areas like atomic file writes, log capping, and rate-limited progress reporting.
This is a Go client library for the Slack API, providing comprehensive coverage of Slack's REST API, Real-Time Messaging (RTM) over WebSocket, Socket Mode for event-driven interactions, and the Block Kit for rich interactive messages. It enables developers to build Slack apps, bots, and integrations with full access to Slack's platform features including messaging, files, admin functions, workflows, and more. The library is organized into several packages: `slack` (main client with all API methods), `socketmode` (WebSocket client for Socket Mode), `slackevents` (Events API parsing), `slacktest` (mock server for testing), and `internal` (backoff, error handling). It uses a functional options pattern for API calls, context propagation for cancellation, and a pluggable retry system. The Block Kit is implemented with builder patterns and custom JSON serialization for type-safe block construction. Key entry points include `slack.New(token)` to create a client, `socketmode.NewClient` for WebSocket connections, and `slackevents.ParseEvent` for Events API payloads. The library handles authentication, rate limiting, pagination, and error responses. External dependencies are minimal, relying primarily on the Go standard library and a WebSocket library for real-time communication.
This repository is a bilingual (Chinese/English) open-content book titled 'Life Level-up Guide' (人生进阶指南), focused on lifelong learning, English acquisition, AI collaboration, personal development, and evidence-based growth. It is published as a VitePress static documentation site with deterministic EPUB and PDF exports. The codebase includes a sophisticated build toolchain with content validation, navigation synchronization, accessibility enhancements, and extensive Playwright end-to-end tests. While not a traditional software application, it demonstrates high craftsmanship in content management, automated publishing, and quality assurance. The repository is actively maintained with CI/CD pipelines, link auditing, and bilingual parity enforcement.
Hexo is a mature, plugin-driven static site generator written in TypeScript for Node.js. It transforms Markdown (or other markup) content into a fully static website, supporting themes, helpers, tags, filters, and generators via a consistent extension API. The core architecture centers on a `Hexo` class that orchestrates configuration loading, plugin registration, file watching (via `Box`), content processing (processors), rendering (renderers with Nunjucks and highlight.js/prism), and static file generation. It includes a built-in CLI (`hexo new`, `hexo generate`, `hexo deploy`, etc.) and a lightweight database (`warehouse`) for metadata. The codebase is well-tested with extensive unit tests and CI across multiple OS/Node versions. While the architecture is clean and extensible, some technical debt exists (e.g., reliance on `bluebird` promises, `@ts-expect-error` workarounds, and complex regex-based processing).
f1-dash is a real-time Formula 1 telemetry and timing dashboard. It consists of a Rust backend that connects to the official F1 live timing SignalR endpoint, ingests data (timing, car metrics, positions, weather, race control messages, team radios), and streams it via Server-Sent Events (SSE) to a Next.js frontend. The frontend displays a leaderboard, track map with driver positions, weather complications, race control messages, team radios, and a schedule page. It supports a delay feature to sync with TV broadcasts. The architecture is multi-service: a realtime service handles the SignalR connection and SSE, an API service provides schedule data from an iCal feed, and the dashboard is a standalone Next.js app. The codebase is well-organized with reusable Rust libraries (SignalR client, state service) and frontend utilities (deep merge, inflate, buffer for delayed playback, map rendering). It demonstrates strong engineering practices, though the project is currently in maintenance mode with the author focusing on other projects.