This is the official repository for the TidyTuesday project, a weekly social data project that provides curated datasets for practicing data wrangling and visualization, primarily in R. The repository contains hundreds of datasets organized by year and week (from 2018 to 2026), each with accompanying metadata, cleaning scripts, and documentation. It also includes GitHub Actions workflows for automated validation and deployment, as well as a set of R scripts for dataset curation and quality control. The repo serves as a community resource for learning data science skills through hands-on practice with real-world data. While not a software application, it demonstrates strong data engineering practices in its curation pipeline and validation infrastructure.
This repository provides TransmittableThreadLocal (TTL), a Java library that extends InheritableThreadLocal to propagate thread-local values across threads even when using thread pools, executors, ForkJoinPool, and other asynchronous constructs. It solves the common problem of context loss (e.g., tracing, security, session) in asynchronous Java applications. The library offers three usage modes: manual wrapping of Runnable/Callable via TtlRunnable/TtlCallable, wrapping executors via TtlExecutors, and transparent bytecode transformation via a Java Agent (TtlAgent) that automatically instruments JDK thread pool classes. The architecture is modular: ttl-core contains the core API and CRR (Capture-Replay-Restore) pattern, ttl-agent provides the agent with Javassist-based transformlets, ttl-kotlin adds Kotlin extensions, and ttl-integrations includes Vert.x 3/4 support. A ttl2-compatible module maintains backward compatibility with the v2 API. The library is widely adopted in the Java ecosystem (e.g., Apache ShardingSphere, SOFARPC) and is under active development with a v3 branch introducing a refined API. While primarily a library, it includes a Java Agent component that operates at the JVM level, making it a hybrid of library and instrumentation tool.
This repository is the source code and build toolchain for the Go by Example website (https://gobyexample.com), an educational tutorial for the Go programming language (a concurrent, channel-based language). The site teaches Go through annotated example programs. The repository contains example source files (Go code with embedded documentation), a set of command-line tools written in Go that parse these examples, render them into HTML using templates, and output a static site. The build pipeline includes syntax highlighting via chroma, Markdown rendering via blackfriday, and deployment to S3. The project also includes a local preview server, a line length enforcer, and CI/CD via GitHub Actions that regenerates the site and diffs against the committed output to ensure consistency. The architecture is a collection of focused Go tools (generate, serve, upload, measure, test) orchestrated by shell scripts. The codebase demonstrates clean separation of concerns, template-driven HTML generation, and a custom lexer for shell output formatting.
curlconverter is a command-line tool and library that converts curl commands into equivalent code snippets in over 30 programming languages and HTTP libraries. It features a modular architecture with a tree-sitter based Bash parser for robust curl command parsing, language-specific generators for target code production, and extensive test coverage. The tool handles complex curl features including authentication, headers, data uploads, multipart forms, proxies, and SSL options, producing runnable code in languages ranging from Python and JavaScript to Rust, Go, and specialized tools like Ansible and HTTPie.
This monorepo (Nx) implements a complete ecosystem for managing and distributing 'skills'—curated, structured instructions for AI coding agents. The codebase reveals a production CLI (`agent-skills`) built with Ink/React for interactive terminal UI, an MCP server (`agent-skills-mcp`) for agent-in-context skill lookup via FastMCP, a Next.js marketplace website for browsing, and a skills catalog with over 150 skill definitions across architecture, cloud, development, quality, security, and other domains. The core library (`@tech-leads-club/core`) uses a clean hexagonal architecture with port/adapter separation for file system, HTTP, environment, logging, and shell operations, enabling testability and future portability. The CLI supports interactive and non-interactive install/remove/update workflows with atomic lockfile writes, append-only audit logging, and content-hash integrity verification. The MCP server implements a progressive disclosure pattern (search → read → fetch/prepare) to minimize token usage, with registry caching and ETag revalidation. The marketplace is highly SEO-optimized with JSON-LD structured data, breadcrumbs, and static generation. Property-based tests (fast-check) for UI components and cache boundaries demonstrate strong engineering discipline. The skills catalog itself is the core product—each skill is a markdown file with YAML frontmatter, optional scripts/references, and trigger phrases, all validated by a custom validation tool and security-scanned in CI. While the architecture is solid and the codebase is actively maintained with frequent releases, some areas show drift risk: duplicate validation scripts across skills, hardcoded benchmark data in the marketplace, and tight coupling to external CDN availability for registry downloads. The cloud-deploy skill references an enormous set of Cloudflare product docs that will inevitably become outdated. Overall, this is a well-crafted, modern TypeScript monorepo that effectively solves the problem of giving AI agents reusable, safe, and discoverable instructions.
This repository is Microsoft's Agent Governance Toolkit, a production-grade multi-language framework (Python, TypeScript, Rust, Go, .NET) for enforcing policy, identity, trust, audit, and sandboxing on autonomous AI agents. In production, it intercepts agent tool calls, messages, and delegations before they reach external services, evaluating them against declarative policies (OPA, Cedar, or custom backends) with deterministic outcomes (allow/deny/escalate/transform). The system provides a full governance plane including a Rust-based policy engine (Agent Control Specification), a service mesh (AgentMesh) with API gateway, trust engine, policy server, and audit collector, a hypervisor for execution rings and sandboxing (Docker, Hyperlight, Nono), compliance verification (OWASP, EU AI Act), SLO monitoring, and a plugin marketplace. Integrations exist for LangChain, CrewAI, AutoGen, OpenAI Agents, Semantic Kernel, MCP, and many other frameworks. The toolkit is deployed as CLI tools (`agt`, `agentmesh`, `agentos`), Docker containers with sidecar patterns, Kubernetes charts, and VS Code/Chrome extensions. The architecture is polyglot with a shared policy engine core written in Rust; the Python SDK is the richest, with the .NET and Go SDKs covering governance middleware and lifecycle management. The codebase is heavily tested with 992 conformance tests across 10 formal specs, fuzzing targets, and CI gates enforcing deterministic policy outcomes, fail-closed behavior, and no-stub registration.
xyOps is a self-hosted, full-stack platform for job scheduling, workflow automation, server monitoring, alerting, and incident response. It is the next generation of Cronicle, built on Node.js with a custom pixl-server framework. The architecture follows a conductor/satellite model: a central master server (conductor) manages job execution, scheduling, and monitoring, while lightweight satellite agents run on remote machines to execute jobs and report metrics. The system includes a rich web-based SPA for administration, real-time WebSocket communication, a RESTful API, and a plugin/extension marketplace. Key features include visual workflow DAGs (split, join, decision, multiplex), multi-master high-availability clustering, SSO integration, ticketing, secrets management with AES-256-GCM encryption, and comprehensive alerting with JEXL expressions. The codebase is well-structured with mixin-based API modules, consistent patterns for CRUD operations, and extensive integration tests. It is actively maintained with frequent releases and security hardening.
Dograh is an open-source voice AI platform for building, deploying, and monitoring conversational voice agents. It provides a visual workflow builder (React/Next.js frontend) where users compose nodes (start, agent, end-call, tools, integrations) into call-handling graphs. The backend (Python/FastAPI) orchestrates real-time voice pipelines using the Pipecat framework, supporting multiple LLM, TTS, and STT providers (OpenAI, Google Gemini, Deepgram, ElevenLabs, etc.) and telephony carriers (Twilio, Vonage, Telnyx, Plivo, Asterisk ARI, WhatsApp, etc.). The system handles inbound/outbound calls, campaign management with traffic splitting and retry logic, text chat sessions, and embeddable widgets. It includes an MCP server that allows AI coding assistants to programmatically create and edit workflows, and auto-generated Python and TypeScript SDKs for programmatic access. The platform is multi-tenant with organization isolation, usage tracking, billing hooks, and extensive observability (Langfuse tracing, PostHog analytics, Prometheus metrics, call event export to BigQuery). Architecturally, the backend follows a modular provider registration pattern: telephony providers, LLM/TTS/STT services, and integration packages (Noveum, Tuner, Paygent) self-register via import side effects, enabling easy extensibility. The workflow engine uses a node-spec system that drives both the UI form renderer and SDK code generation, ensuring consistency. The system uses PostgreSQL (with pgvector for embeddings), Redis (for caching, pub/sub, rate limiting, task queue), and object storage (S3/MinIO). Deployment supports Docker Compose, Helm/Kubernetes, and a devcontainer setup. Key entry points include the FastAPI application (api/app.py), the MCP server (api/mcp_server/server.py), the ARQ background worker (api/tasks/arq.py), and the telephony ARI manager (api/services/telephony/ari_manager.py). The frontend is a Next.js application with a workflow editor, run viewer, settings pages, and billing dashboard. The SDKs provide typed workflow builders and client libraries for both Python and TypeScript.
torlink is a terminal-based torrent client that combines a rich Text User Interface (TUI) with headless daemon modes for torrent search, download, seeding, and file serving. Built with TypeScript, Node.js, and React (via Ink for TUI rendering), it provides zero-configuration access to curated torrent sources across categories like games, movies, TV, and anime. The application features parallel source querying, result deduplication, automatic seeding with optional file deletion, and persistent state management for queues, history, and seeds. The architecture follows a modular design: the TUI layer (src/ui) handles interactive modes, daemon services (src/daemon) manage headless operations (serve, files, watch, seed, attach), core download logic (src/download) manages the torrent queue and engine integration, and source plugins (src/sources) fetch torrents via RSS, APIs, or web scraping. Key utilities include atomic file writes, resilient HTTP fetching, caching, and format helpers. The CLI entry point (scripts/cli-entry.cjs) handles Node version checks and WebRTC fallbacks before launching the appropriate mode. External dependencies include Ink for TUI rendering, webtorrent for torrent handling, node-datachannel for WebRTC fallbacks, and various HTTP clients. The project maintains active development with recent commits, comprehensive test coverage, and CI workflows. While dependency pinning indicates managed compatibility risks, the codebase demonstrates strong engineering practices through isolated utilities, reactive patterns for concurrent searches, and cross-platform path handling.
YouDub WebUI is a full-stack video localization platform that enables users to import videos, transcribe speech via Whisper, translate via OpenAI-compatible APIs, clone voices with VoxCPM2, separate audio with Demucs, align subtitles with Qwen3 Forced Aligner, and export dubbed videos or subtitles. The architecture is plugin-based (Cordis framework) with a Node.js/TypeScript host orchestrating Python subprocesses for ML inference, a Next.js web frontend, and native desktop apps for macOS (Swift) and Windows (C#). The system features a task engine with queuing, cancellation, retry, and partial rerun; a worker protocol using NDJSON over stdin/stdout; and a comprehensive setup service that downloads and verifies model weights. While primarily an application, it includes research-grade model consumption and detailed validation records documenting real-media runs with SHA-256 hashes and human listening feedback. The codebase is actively maintained with recent commits, CI/CD pipelines, and extensive unit tests for contracts, protocols, and permissions.
A comprehensive tool for removing watermarks from Gemini AI-generated images and videos. It provides multiple deployment options: a Chrome extension, a Tampermonkey userscript, an npm package (SDK), a CLI, and an AI agent skill. The core algorithm uses mathematically exact reverse alpha blending with pre-calibrated alpha maps to remove the Gemini logo without degrading underlying image quality. The system includes a sophisticated pipeline for detection, candidate selection, alpha trial, repair, and quality evaluation, with support for both image and video watermark removal. The repository is hybrid: while primarily an application, it contains an extensive set of data/research scripts for benchmarking, alpha profile analysis, video residual analysis, and release quality gating, reflecting a data-driven development approach. The codebase is well-structured with clear separation of concerns, extensive test coverage, and modular components that can be reused in other projects.
Porffor is an ahead-of-time (AOT) JavaScript compiler and lightweight runtime, written primarily in JavaScript and TypeScript. It compiles JS/TS source code into C, then to native binaries via an external C compiler (e.g., TCC, GCC, or Clang). The system includes a full ECMAScript built-in library, a self-hosted compiler pipeline (the compiler compiles itself), and a custom intermediate representation (IR) with constant folding, effect tracking, and type inference. It supports modern JS features including async/await, generators, Promises, classes, modules, and most built-in objects, with a particular focus on performance through techniques like coroutine lowering, inline caching, and compile-time evaluation. Architecturally, the compiler is a classic three-stage pipeline: parser (custom ESTree-compatible parser with full TypeScript support), code generator (AST-to-IR lowering with closure analysis and type inference), and renderer (IR-to-C code generation with runtime embedding). The runtime is split into a small C core (providing garbage collection, coroutine support, and native fetch) and JS-implemented built-ins that leverage an explicit memory model and low-level IR intrinsics. The project also includes a comprehensive benchmark suite (based on the V8 benchmark suite) and a test262 runner for ECMAScript conformance tracking. A notable aspect is the self-hosting infrastructure: the compiler can compile its own source code, and the repository includes build scripts, a profile-guided optimization pipeline in CI, and cross-platform binary releases. While primarily an application (compiler/runtime toolchain), it also contains non-trivial performance measurement and conformance tracking code, giving it a slight hybrid character. The codebase is early-stage but shows high engineering quality with many carefully optimized components, though some files are monolithic and tightly coupled.
JetKVM is an open-source KVM-over-IP device firmware that enables remote keyboard, video, and mouse control over IP networks. The codebase is a full-stack embedded application: a Go backend manages USB gadget emulation (keyboard, mouse, mass storage, audio, serial), WebRTC video/audio streaming, OTA updates, network configuration (DHCP, static IP, Tailscale), MQTT integration, and cloud connectivity. A C/C++ native layer (with LVGL UI) handles low-level hardware access via V4L2 video capture, Rockchip hardware encoding, and EDID management. The React/TypeScript frontend provides a responsive web UI for device management, remote desktop, virtual media mounting, and system settings. The architecture is clean with well-defined packages (logging, sync, diagnostics, HID RPC protocol) and comprehensive E2E testing via Playwright. While tightly coupled to the RV1106 SoC and Linux kernel interfaces, the code demonstrates high craftsmanship with robust concurrency patterns, configfs transaction management, and signature-verified OTA updates.
FlowPilot is a Chrome extension that automates the registration, verification, and delivery of accounts for AI platforms like OpenAI/ChatGPT, Grok (xAI), and Kiro (AWS). It handles email verification codes from a wide range of providers (Hotmail, iCloud, 2925, Gmail, etc.) and SMS verification through multiple services (5sim, HeroSMS, MaDao). The extension features a step-based workflow engine that composes registration flows dynamically based on signup method, payment mode, and delivery target. It includes an auto-run controller for batch account creation, account delivery to external APIs (CPA, SUB2API, etc.), and a contribution system for sharing accounts. Architecturally, it follows the standard Chrome extension pattern with background scripts, content scripts, and a sidepanel UI. The codebase is modular, using factory functions with dependency injection for testability. It has an extensive test suite with over 200 test files, though tests rely on a fragile function extraction method. The project is actively maintained with frequent commits and a versioned release cycle. The codebase demonstrates good engineering practices including a registry pattern for steps and mail rules, i18n support for Chinese and English, and reusable UI components. However, there are some maintenance concerns such as duplicate files, hardcoded external URLs, and dormant code paths for payment features.
ExecuTorch is PyTorch's unified solution for deploying AI models on-device (mobile, embedded, edge). It enables direct export from PyTorch without intermediate format conversions (.onnx, .tflite) and powers Meta's production on-device AI across Instagram, WhatsApp, Quest 3, and Ray-Ban Meta Smart Glasses. The framework provides an ahead-of-time (AOT) compilation workflow: Export → Compile → Execute, supporting LLMs (Llama 3.2/3.1/3, Qwen 3, Phi-4-mini), vision (MobileNetV2, DeepLabV3, YOLO26), speech (Whisper), and multimodal models (Llava, Voxtral) across 12+ hardware backends including XNNPACK, CoreML, Qualcomm QNN, MediaTek Neuropilot, ARM Ethos-U, NXP, Cadence DSP, Vulkan, CUDA (experimental), Metal (experimental), and MLX (experimental). The architecture is modular with core runtime (C++/C), export pipeline (Python), backend-specific delegates, and examples/tools for model conversion and benchmarking. Key entry points include the Python API (torch.export.export() → to_edge_transform_and_lower() → .to_executorch()), C++ API (executorch::runtime::Module), backend partitioners (XnnpackPartitioner, CoreMLPartitioner), and command-line tools for model export and benchmarking. Data flows involve model export to Edge IR (EXIR), partitioning/lowering for backend, serialization to .pte, and runtime execution via delegate interfaces. External dependencies include PyTorch, FlatBuffers, backend-specific SDKs (QNN, Ethos-U, CoreML/Metal, Vulkan, WebGPU), CMake, Buck2, and testing frameworks. The codebase demonstrates strong engineering practices with reusable components like the visitor pattern for operator lowering, quantization pipelines for LLMs, memory planning utilities, and a flexible delegate framework. While actively maintained with frequent commits and CI/CD, technical drift is medium due to experimental backends, generated code synchronization challenges, and conditional build complexity across numerous hardware targets.
Arduino CLI is a command-line tool and gRPC daemon for Arduino embedded development. It manages board platforms (cores), libraries, sketches, compilation, upload, monitoring, and debugging. The architecture is dual: a CLI frontend using the Cobra framework and a gRPC server (daemon mode) that exposes the same operations via protobuf-defined services. The core domain logic is organized under `internal/arduino/` with subsystems for building (preprocessor, compiler, linker, diagnostics), package management (index loading, install/uninstall, dependency resolution), sketch handling (profiles, YAML config), and hardware discovery/monitoring. External dependencies include gRPC, protobuf, Cobra/Viper for CLI, and Arduino-specific libraries for path handling, properties, serial communication, and pluggable discovery protocols. The system supports cross-platform operation (Linux, macOS, Windows) and includes extensive integration tests that exercise real CLI commands against isolated environments.
Inspira UI is a curated collection of beautifully designed, reusable Vue & Nuxt UI components, inspired by Aceternity UI and Magic UI. The repository contains a Nuxt 4 documentation site built with Docus, featuring live interactive demos with DialKit config panels, multi-language documentation (en, fr, cn), and a component registry for CLI-based copy-paste installation. It delivers 150+ components spanning backgrounds, cards, text animations, buttons, cursors, device mockups, special effects, and more, many powered by WebGL (Three.js, OGL), canvas, or GSAP animations. The codebase is organized with a consistent pattern: each component has a Vue SFC under `app/components/inspira/ui/`, a demo file under `app/components/inspira/examples/`, and a config panel under `app/components/inspira/configs/`. The documentation site itself is a Nuxt application that also serves as the component showcase, with a rich set of shared utilities like `ComponentPlayground`, `ComponentTabs`, and `DialKitConfigPanel`. While primarily an application (component library + docs site), it has a data-like registry pipeline for generating installable packages from the component sources. The repo is actively maintained with a large community following (5k+ stars) and frequent commits.
Stoplight Prism is an open-source HTTP mock server and validation proxy driven by OpenAPI specifications (v2, v3, v3.1) and Postman Collections. It provides two primary CLI commands: `prism mock` to simulate an API from a schema definition, and `prism proxy` to validate requests and responses against a spec while forwarding traffic to a real upstream. The architecture is a monorepo with four packages (`core`, `http`, `http-server`, `cli`) that implement a functional pipeline: route matching, input validation (body, headers, query/path parameters, security), content negotiation, and response generation (static examples or dynamic faker-generated data). It also supports callback mocking, CORS handling, and RFC 7807 problem detail errors. The codebase is written in TypeScript with heavy use of fp-ts for composable error handling and dependency injection via reader monads. While the project is mature and well-tested (unit, integration, and a text-based harness test suite), its tight coupling to Stoplight internal packages and the steep learning curve of fp-ts reduce its overall reusability for external projects. It is not a data research repository.
Tencent/wujie is a production-grade micro-frontend framework that achieves native-level isolation by combining iframe sandboxing for JavaScript execution with Web Components (Shadow DOM) for CSS scoping. Unlike other micro-frontend solutions that rely on JavaScript sandbox polyfills (e.g., 'with' statements), Wujie leverages the browser's built-in iframe security model, making it robust against prototype pollution and global variable conflicts. The framework is implemented as a monorepo containing a core library (wujie-core), framework-specific integrations for Vue 2/3 and React, comprehensive examples, and an extensive test suite. The core provides lifecycle APIs (startApp, preloadApp, destroyApp) and supports multiple running modes: alive (keep-alive), singleton (lifecycle-based), and rebuild (full destroy each time). It includes a plugin system for custom asset loaders (HTML, CSS, JS), routing synchronization between main and sub-apps, and a decentralized EventBus for cross-application communication. The architecture handles degradation gracefully: if Proxy or WebComponent is unavailable, it falls back to a pure iframe with Object.defineProperty-based sandbox. The repository exhibits high craftsmanship in several areas: a dedicated EventCleanupTracker for preventing memory leaks, a custom proxy generator that patches cross-realm instanceof checks, and deferred style loading to support libraries like TinyMCE. Integration and unit tests cover lifecycle, plugins, routing sync, and memory leak scenarios. The accompanying documentation site provides detailed guides and API references. However, the codebase shows signs of maintenance burden: the example sub-apps use outdated frameworks (Angular 12, React 16/17), the integration test setup is complex and slow, and the dense patching of native DOM APIs introduces fragility across browser updates. Overall, it is a well-architected and actively maintained solution for micro-frontend orchestration.
Text Grab is a Windows desktop application for OCR text capture and editing. It provides multiple capture modes: full-screen grab, grab frame (interactive region selection), edit text window (with text/spreadsheet/markdown modes), and quick lookup. It integrates multiple OCR engines (Windows built-in OCR, Tesseract, Windows AI) and UI Automation (accessibility tree) for text extraction. The architecture is a monolith with a WPF UI, services layer, utilities, and models. Key entry points include App.xaml.cs, FullscreenGrab, GrabFrame, EditTextWindow, QuickSimpleLookup, and SettingsWindow. Data flows: screen capture or file input → OCR processing → word border rendering → text output with post-processing (templates, patterns, calculations). External dependencies include Windows SDK, Tesseract, ZXing.Net, Magick.NET, PdfPig, Markdig, NCalcAsync, UnitsNet, and others. The codebase demonstrates high craftsmanship with reusable components like the undo/redo system, calculation service, image change detector, automation profile, and custom UI controls. It has extensive test coverage (unit tests and UI automation tests) and CI/CD pipelines. However, some classes are large and tightly coupled, and the Windows-specific dependencies limit portability.