Megatron-MoE-ModelZoo is a production-ready toolkit for training Mixture-of-Experts (MoE) large language models including DeepSeek-V3, Qwen3, and Mixtral. It provides SLURM job submission scripts, Dockerfiles for hardware-optimized containers, YAML configuration files, and best practice guides for launching training jobs on HPC clusters. The repository integrates with NVIDIA's Megatron-LM framework (dev branch) to enable efficient distributed training of MoE models across tensor, pipeline, and expert parallelism dimensions. Key features include precision selection (BF16/FP8/MXFP8), checkpoint conversion utilities, and memory estimation tools for hardware planning.
SmartDNS-rs is a high-performance, cross-platform DNS server and CLI resolver written in Rust. It functions as a local DNS proxy, intercepting and routing DNS queries through a sophisticated middleware pipeline. It supports a wide array of upstream protocols (UDP, TCP, DoT, DoQ, DoH, DoH3) and provides advanced features like ad-blocking, domain-based policy routing, fastest-IP selection via multi-protocol ping (ICMP, TCP, HTTP, HTTPS), and comprehensive caching with prefetch and serve-expired logic. The architecture is centered around a modular middleware chain (`src/infra/middleware.rs`) that processes incoming requests through components for caching, CNAME rewriting, dual-stack IP selection, bogus NXDomain filtering, nftset/ipset integration, hosts file parsing, and dnsmasq lease integration. Configuration is handled by a robust parser using nom combinators, supporting a wide array of directives. The server exposes a REST API for runtime management and includes platform-specific service management for systemd, launchd, Windows services, and OpenWrt. Key entry points include the CLI (`src/cli.rs`) with subcommands for running the server, managing services, testing configuration, and resolving domains. The core server loop is in `src/app.rs`, with protocol-specific listeners in `src/server/`. The project demonstrates strong engineering practices with its middleware pattern, abstract service installer, and efficient domain matching data structures, though it carries some technical debt in the form of patched upstream dependencies and a few unimplemented stubs.
KVIrc is a production-grade, cross-platform IRC client built on the Qt framework. It features a custom embedded scripting language called KVS (KVIrc Script) with full support for events, aliases, popups, timers, arrays, hashes, object-orientation, and control flow. The application is modular: a core library (kvilib) provides utilities (strings, containers, config, networking, cryptography), the main app (kvirc) manages connection state, IRC protocol parsing, and UI, while dozens of loadable modules (src/modules/) add DCC file transfers, voice/video, media player integration, encryption, language detection, UPnP, KTorrent interface, and more. The UI is heavily configurable with theming, options dialogs, toolbars, and notifier windows. The codebase shows a high degree of craftsmanship in its plugin system, abstraction layers, and the KVS scripting engine, but also carries significant technical debt from its long history (code dating back to the late 1990s) – including manual memory management, custom container classes, conditional compilation for many optional features, and some deprecated Qt API usage.
The SmartNoise SQL/Synth/Eval monorepo is a differentially private (DP) data analysis toolkit. It provides three main packages: `snsql` (DP SQL query rewriting with calibrated noise), `snsynth` (DP synthetic data generation via MWEM, GANs, MST, and other mechanisms), and `sneval` (evaluation of synthetic data quality). The SQL package includes a custom ANTLR-based SQL parser (`SqlSmall.g4`) that rewrites queries to enforce DP, supports multiple backends (Pandas, Spark, PostgreSQL, SQL Server, BigQuery), and tracks privacy budgets via an odometer. The synth package offers a rich set of synthesizers (DPCTGAN, PATECTGAN, MWEM, MST, AIM, etc.) with a consistent `fit`/`sample` API and a `TableTransformer` pipeline for preprocessing. The eval package provides metrics for comparing real vs. synthetic data, including accuracy, bias, and suppression/fabrication counts. The repository includes extensive tests (SQL parsing, mechanism accuracy, synthesizer round-trips) and sample notebooks demonstrating DP workflows.
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.
Nova Proximity is a modular Python security scanner designed specifically for MCP (Model Context Protocol) servers and Agent Skills. The application provides comprehensive discovery and analysis capabilities, including tool/prompt/resource enumeration for MCP servers and structural/permission analysis for Agent Skills. Its architecture separates concerns into distinct libraries: mcp_scanner_lib for MCP protocol handling, skill_scanner_lib for Agent Skills analysis, and nova_evaluator_lib for NOVA-powered security evaluation. The tool supports multiple transport mechanisms (stdio, SSE, Streamable HTTP) with automatic fallback, provides detailed function signature analysis, and generates actionable security reports with pattern-specific remediation guidance.
This repository provides a comprehensive, production-grade Field-Oriented Control (FOC) library for Permanent Magnet Synchronous Motors (PMSM) targeting embedded microcontrollers (STM32G4, CH32V3). It is written in C and organized into modular algorithm files covering coordinate transforms (Clarke, Park), PWM modulation (SVPWM, SPWM), multiple control strategies (PID, LADRC, SMC, STA), sensor feedback (encoder, Hall, sensorless observers like HFI, SMO, NLFO), and advanced features (MTPA, field weakening, harmonic suppression, cogging calibration, dead-time compensation, feedforward, disturbance observer, parameter identification). The architecture is driven by interrupt-based control loops (high-frequency current loop, low-frequency state machine, and serial communication loop) with compile-time configuration via macro switches and user-supplied hardware abstraction layers. The repository also includes open-source hardware designs (schematic and PCB for a robot-joint motor driver), a QT-based host computer application, Simulink simulation models, and a complete STM32G4 example project. Although the library contains multiple coexisting versions and v4.0.0 is partially incomplete, the core modules are well-crafted, independently reusable, and demonstrate advanced control theory implementation suitable for robotics, drones, industrial servos, and electric tools.
NGBoost is a Python library for probabilistic gradient boosting that produces full predictive distributions rather than point estimates. It implements the Natural Gradient Boosting algorithm described in the research paper (arXiv 1910.03225). The library provides a scikit-learn-compatible API with NGBRegressor, NGBClassifier, and NGBSurvival classes, supporting a wide range of distributions (Normal, Bernoulli, Poisson, Gamma, Weibull, Beta, MultivariateNormal, etc.) and scoring rules (LogScore, CRPScore). A standout feature is the SymPy-based distribution factory (sympy_utils) that automatically derives gradients and Fisher Information from symbolic expressions, enabling easy creation of custom distributions. The architecture is modular: a core boosting loop (ngboost.py) works with pluggable base learners (learners.py), distributions (distns/), and scores (scores.py), combined via a manifold pattern (manifold.py). The library also includes survival analysis with censored scores, partial_fit for incremental learning, and backward-compatible model loading. While primarily a software library, it has strong research roots with experimental scripts, figure generation, and extensive Jupyter notebook examples. The codebase is well-structured and tested, though some deprecated sklearn usage and duplicated documentation content indicate moderate technical drift.
This is a curated collection of roughly 100 self-contained Claude Code skills (agent plugins). Each skill is a directory containing a SKILL.md trigger definition, CLI scripts in Python, Node, or bash, reference documentation, and frequently unit tests; the Claude Code agent invokes them from natural language. The collection spans meeting transcription and summarization, web and deep research, image and audio generation, Telegram and Gmail integration, reversible PII redaction, TDD scaffolding, iOS and Tauri release engineering, project scaffolding, and personal analytics over an Obsidian vault. It functions as a plugin marketplace: skills install into ~/.claude/skills and are triggered on demand.
SymTorch is a Python library for deep learning interpretability via symbolic regression. It wraps PyTorch neural network components (layers, submodules) or arbitrary callable functions (e.g., LLM inference, scikit-learn models) and uses the PySR symbolic regression engine (Julia-backed) to discover human-readable mathematical equations that approximate the wrapped component's input-output behavior. The library provides a unified SymbolicModel class that can operate at the layer level (using forward hooks to capture intermediate activations) or in a model-agnostic mode for any black-box function. It also supports local interpretability via SLIME (synthetic neighborhood sampling with weighted regression) and progressive dimensionality reduction through configurable pruning schedules (exponential, linear, cosine decay). The primary workflow involves wrapping a model, optionally training with pruning, calling distill() to run symbolic regression, inspecting discovered equations via show_symbolic_expression(), and optionally switching the forward pass to use the symbolic equation instead of the original block via switch_to_symbolic(). The architecture is monolithic: the SymbolicModel class (~2300 lines) encapsulates all functionality including caching, PySR parameter management, forward hook handling, SLIME sampling, pruning schedules, and serialization via dill. While this centralization simplifies the public API, it creates a single point of maintenance and limits modular reuse. The library relies on several heavy external dependencies: PySR (which requires Julia), PyTorch, SymPy, and dill. Documentation includes comprehensive API reference, Jupyter notebook demos (PINNs, GNNs, LLM arithmetic probing), and case studies demonstrating symbolic extraction from physics-informed neural networks and small language models. The codebase demonstrates solid engineering with good docstrings, extensive caching to avoid redundant computations, and thoughtful design decisions like configurable pruning schedules and SLIME parameters. However, there are signs of academic development: future-dated version numbers (1.1.1 docs vs 1.0.1.post1 setup.py), local path references in demos, and incomplete decomposition (TODO comments about breaking up the class). The testing suite exists but heavily mocks PySR, which may miss integration issues. Overall, SymTorch is a functional, research-oriented interpretability toolkit with clear value for extracting symbolic equations from trained models, but its monolithic structure and external dependencies limit its reuse as a standalone component.
This repository is the official home of the CSS Working Group's editor drafts, serving as the authoritative source for the development of CSS specifications. It is a hybrid standards development platform, functioning primarily as a specification authoring and build system. Its core function is to store, build, and publish CSS specification documents (in Bikeshed .bs format) along with their associated examples, test data, and issue tracking. The architecture is a monorepo of loosely coupled specification modules (e.g., css-color-4, css-grid-3), each containing its own source file, build instructions (Makefile), and assets. Shared infrastructure includes build scripts (bin/), CI/CD workflows (.github/), and bundled third-party libraries (MathJax, ReSpec, jQuery) for rendering and authoring. The primary data flow involves editing source files, running the Bikeshed preprocessor, and publishing the resulting HTML. The repository contains several hidden gems of high craftsmanship. The color conversion algorithms in css-color-4/conversions.js and deltaE2000.js are production-grade, self-contained implementations of complex color science. The resizeTestHelper.js provides a robust pattern for testing asynchronous browser APIs. The custom diagram elements in css-view-transitions-1 (slides.js, scaler.js) demonstrate a novel approach to embedding interactive documentation. While the specification content is actively maintained with thousands of open issues and recent commits, the repository suffers from significant technical drift. Bundled dependencies like MathJax v2.0, jQuery 1.7.2, and the legacy ReSpec.js are severely outdated, posing security and compatibility risks. The presence of eval usage, plaintext credential references in Makefiles, and mixed tooling (Bikeshed vs. ReSpec) further contributes to a high technical debt profile. Despite this, the core mission of developing CSS specifications is executed effectively, and the reusable components are genuinely valuable.
Tranquilpeak is a comprehensive, responsive theme for the Hexo static blog framework. It provides extensive features such as cover images, image galleries with Fancybox, social sharing, sidebar customization, search via Algolia, comment systems (Disqus, Gitment, Gitalk), and a rich set of tag plugins (alerts, highlighted text, images, videos, tabbed code blocks). The codebase is well-organized: SCSS is modular with reusable mixins and variables, client-side JavaScript is structured in isolated modules with clean event handling, and server-side Hexo plugins (filters, helpers, tags) demonstrate solid Node.js patterns. The theme is mature and has been widely adopted, but the repository shows signs of stagnation (no recent commits despite a few open issues), and some dependencies are outdated. Overall, it is a high-quality theme with reusable components, but new development has stalled.
nodemon is a CLI tool and library that monitors a directory for file changes and automatically restarts a specified command (typically a Node.js application). It parses command-line arguments and configuration files (nodemon.json, package.json) to determine watch paths, ignore patterns, file extensions, and the command to execute. It uses chokidar for file system watching and manages child processes via fork or spawn. When changes are detected, it matches the changed files against configured rules and restarts the child process if appropriate. It supports custom signals, delay, legacy polling, and event hooks. The architecture is monolithic with a library API, key modules include CLI parser, config loader, rule engine, file watcher, and process manager. The codebase relies on non-standard Node.js APIs (e.g., process.stdin.setEncoding, child_process.fork, process.versions.node), indicating significant technical drift from standard Node.js, though the tool remains widely used and actively maintained.
HeadlessX is a self-hosted, full-stack web scraping and data extraction platform designed for stealth and reliability. It provides a unified API, web dashboard, CLI, and MCP (Model Context Protocol) server to perform browser-based automation tasks. The system specializes in anti-detection scraping using a custom Firefox fork (Camoufox/Headfox) with advanced fingerprinting, proxy support, and CAPTCHA solving via embedded ONNX models. It offers 'operators' for website scraping (HTML, JS-rendered, screenshots, markdown), crawling, sitemap mapping, Google AI Search, Tavily search/research, Exa search, and YouTube metadata extraction. The architecture is a monorepo managed by Nx and pnpm, featuring a central Express API server, a Next.js dashboard, a BullMQ/Redis queue worker, a Python FastAPI sidecar for YouTube, a Go sidecar for HTML-to-Markdown, and published packages for the CLI and browser launcher. It relies on PostgreSQL for persistence and Redis for job queues and caching. The system supports three deployment modes (developer, self-host, production) via Docker Compose. Strengths include a well-architected monorepo with a clear operator pattern, genuinely reusable components like the headfox-js browser launcher and CaptchaSolverService, and a modern tech stack (Next.js 16, React 19, Express 5, Prisma 7). The MCP server integration is a standout feature, allowing AI agents to directly utilize its scraping capabilities. Weaknesses include some duplicated code across operator workbenches, widespread use of 'as any' casts, committed build artifacts (Nx cache), a transitional state between versions (v2.1 to v2.5 under a new org), and a lack of automated tests for the core API and web applications. This repository is ideal for developers and teams needing a self-hosted, reliable, and stealthy web scraping solution that can be integrated into AI agent workflows or used directly via API/CLI. It is a good, functional project with several high-craftsmanship components, but it carries some technical debt typical of a rapidly evolving, multi-language monorepo.
Peanut-GB is a high-speed, portable Game Boy (DMG) emulator library implemented as a single C99 header file (peanut_gb.h). It provides a complete emulation core including CPU, memory, LCD, cartridge (MBC1/2/3/5), RTC, serial link, and boot ROM support. The library is designed for easy integration into other projects via a callback-based architecture where the frontend provides ROM read, RAM read/write, error handling, and optional LCD line drawing and audio callbacks. The repository includes multiple example frontends demonstrating integration with SDL2 (full emulator with audio and controls), MiniFB (minimal X11 framebuffer), a debug CLI, a Nuklear-based GUI debugger with disassembler and VRAM viewer, and a benchmark tool. A test suite using the minctest.h framework runs Blargg's CPU instruction and timing tests as well as the dmg-acid2 LCD hash test. The library is MIT-licensed and has been used in several real-world projects (Pico-GB, CPBoy, PlayGB). While the core is well-crafted and portable, known inaccuracies exist (line-by-line LCD rendering, audio timing) and some features are incomplete (MBC6/7, camera). The build system is fragmented across Makefiles and CMake, and some examples have version drift in vendored dependencies.
This repository is a comprehensive plugin marketplace and reference implementation for legal practice automation using Anthropic's Claude AI. It contains 12 first-party plugins (commercial, corporate, employment, privacy, product, regulatory, AI governance, IP, litigation, legal clinic, law student, and a builder hub) plus one vendor plugin from Thomson Reuters. Each plugin provides a set of 'skills' (prompt-engineered workflows) invoked via slash commands, a cold-start interview to configure the AI to a specific legal professional's role and preferences, and optional scheduled agents. The repo also includes five managed-agent cookbooks demonstrating multi-agent orchestration with tool isolation (read-only subagents, write leaf, orchestrator with no write access). While the vast majority of content is markdown prompt files, the repository also contains reusable Python and shell scripts for deployment, validation, and linting of agent configurations. The system is designed to be deployed on Claude Code or Claude Cowork, with MCP connectors for legal research tools, document management, and other integrations. It emphasizes citation provenance, injection defense, and consequential-action gates for non-lawyer users.
This repository is the primary web frontend (dApp) for the Juicebox protocol, a decentralized programmable funding platform on Ethereum and other EVM chains. It is a full-stack Next.js application that allows users to create, manage, and contribute to projects across multiple protocol versions (V1, V2/V3, V4/V5). The application handles the complete project lifecycle: creation via a multi-step wizard, funding cycles, payout splits, token issuance, NFT rewards, governance (ballots, Safe multisig), and treasury management. It also serves as the project's marketing site with pages for about, success stories, and FAQs. Architecturally, it is a monolithic Next.js application with a strong internal package structure separating protocol versions. It employs a Provider/Context pattern for dependency injection (e.g., V2V3ProjectContext, CurrencyContext) and Redux for complex form and flow state. On-chain data is read via GraphQL subgraphs (Apollo) and direct contract calls (ethers/wagmi), while off-chain metadata is stored on IPFS and cached in Supabase. The codebase demonstrates sophisticated patterns for blockchain interaction, including a generic contract reader with state change detection and a standardized transaction abstraction. The codebase is actively maintained with recent commits and a low issue count. It contains several well-crafted, reusable components. However, it suffers from significant code duplication between the v2v3 and v4v5 packages, an incomplete migration from ethers v5 to viem/wagmi, and scattered commented-out code and TODOs. This technical drift is manageable but requires careful navigation for new contributors or AI agents evaluating the code for reuse.
This repository hosts the landing page for ClawSweeper, a conservative maintenance bot for OpenClaw repositories. It is a single-page static site built with handcrafted HTML and CSS, deployed on Vercel. The page describes the bot's purpose, operating lanes, guardrails, and watched repositories. The codebase is minimal but exhibits high craftsmanship in its editorial dark theme, responsive design, and accessibility features. The included GitHub Actions workflow dispatches events to the actual ClawSweeper bot repository, enabling automated review triggers. This is not the bot itself; the bot lives in a separate repository (openclaw/clawsweeper). The landing page is well-maintained and serves as a polished informational site.
Elysia is an open-source agentic platform that uses a decision tree architecture to dynamically select and execute tools for searching and reasoning over vector databases (Weaviate). The core is a `Tree` class that maintains conversation history, an environment of retrieved objects, and a decision loop: at each step, an LLM (via DSPy) chooses which tool to call based on the current state and user goal. Built-in tools include hybrid/semantic query, aggregate, summarization, visualisation, and linear regression; custom tools can be added via a `@tool` decorator or by subclassing `Tool`. The system preprocesses Weaviate collections to generate LLM-created summaries, field mappings, and statistics, enabling adaptive query formulation. The platform includes a full-stack web application: a FastAPI backend with WebSocket endpoints for real-time query execution, and a built Next.js frontend (served as static files) offering a UI for conversations, collection management, tree visualisation (React Flow), and feedback collection. The backend manages multi-user and multi-conversation state via `UserManager`/`TreeManager`, persists trees to Weaviate, encrypts API keys, and supports feedback-driven few-shot learning. A CLI entry point (`elysia start`) launches the API server.
This repository is the official CLI tool for Firecrawl, a web scraping, crawling, and structured data extraction platform. Built with Node.js and TypeScript, it provides a comprehensive command-line interface (CLI) using the Commander framework. In production, it allows users to scrape individual URLs, perform multi-page crawls, search the web (text, images, news), map site structures, interact with cloud browser sessions, create recurring content monitors, and use AI agents for complex extraction tasks. It also includes a research paper search feature covering ~43 million abstracts from PubMed, bioRxiv, medRxiv, and arXiv, as well as a developer index for searching GitHub issues, PRs, and READMEs. The CLI is designed for both direct human use and integration with AI coding agents via MCP (Model Context Protocol) and a skills system. Architecturally, it follows a command-per-file pattern in src/commands/, with shared utilities in src/utils/ for API client management, configuration/credential handling, output formatting, authentication (PKCE OAuth, API key, keyless free tier), and job polling. The core data flow is: user input -> command handler -> Firecrawl REST API (cloud or self-hosted) -> formatted output to stdout or file. External dependencies include the firecrawl SDK, commander, @inquirer/prompts, yaml, and zod-to-json-schema. The tool supports binary builds via Bun compile and is distributed via npm, Homebrew, and GitHub Releases with .deb/.rpm packages. It also includes interactive setup wizards, MCP server installation for coding agents, and a native skill installer. While primarily an application, the research paper search feature gives it a hybrid data-access character, but it does not contain data pipelines, notebooks, or analytical models. The codebase is well-tested (Vitest) and actively maintained, with CI/CD workflows for testing, npm publishing, and binary releases. However, the large command surface and agent-specific integrations introduce some maintenance complexity, and the reliance on the firecrawl SDK and external APIs means changes upstream could require updates.