This repository is a companion documentation site for Zhou Zhihua's 'Machine Learning' (Watermelon Book), providing detailed step-by-step formula derivations for all chapters. It is built with VitePress, a static site generator, and deployed to GitHub Pages. The site includes 16 chapters of mathematical derivations, an errata page tracking corrections across print editions, and French translations for the first two chapters. While the content is educational and not a software application in the traditional sense, the repository functions as a VitePress project with custom theme configuration, MathJax rendering, and CI/CD deployment. It is actively maintained by the Datawhale community and serves as a learning resource for machine learning practitioners.
DeepSeek-OCR is an inference repository for a multimodal OCR model that combines vision encoders (SAM and CLIP) with a large language model (DeepSeek-V2/V3) to perform optical character recognition with layout awareness, supporting native and dynamic resolution processing. The system provides two inference paths: a Hugging Face Transformers integration for simple usage and a custom vLLM integration for high-throughput batched inference, including PDF processing and evaluation benchmarks. The architecture is a monolithic model definition with separate modules for vision encoding (deepencoder), image preprocessing (process), and vLLM glue code, all tightly coupled to the specific model architecture. The codebase is functional and demonstrates competent engineering for research-grade inference, but lacks production hardening, documentation, and consistent coding standards.
This repository contains a collection of deployment and management scripts for setting up and maintaining a multi-protocol proxy server (sing-box) on VPS and free hosting platforms (Serv00/Hostuno). The system automates the installation of five proxy protocols (Vless-reality, Vmess-ws, Hysteria-2, Tuic-v5, Anytls), generates TLS certificates, configures Cloudflare Argo tunnels for CDN proxying, and provides keep-alive mechanisms via cron, GitHub Actions, Cloudflare Workers, and a Node.js web server to prevent service downtime on free hosts. The primary entry points are interactive bash scripts (`sb.sh` for VPS, `serv00.sh` for Serv00) and a non-interactive keep-alive script (`serv00keep.sh`). The architecture is a set of loosely coupled shell scripts and a small Express.js application, not a monolithic service. External dependencies include sing-box, cloudflared, and standard Linux utilities. The code is functional and widely used (10k+ stars) but exhibits typical script-level craftsmanship: long monolithic functions, global variable usage, and tight coupling to specific hosting environments. The last commit date (2026-10-13) appears anomalous and likely a data error, but the repository shows active maintenance with recent stars and forks.
AdAway is an Android ad-blocking application that operates via two methods: modifying the system hosts file (root method) or running a local VPN to intercept and filter DNS queries. It manages blocklists from multiple sources (URLs, local files, Git repositories), parses them into a local SQLite database using Room, and applies the rules to block, allow, or redirect domains. The application includes a comprehensive UI for managing sources, viewing DNS request logs, configuring preferences (theme, update channel, VPN excluded apps), and a welcome wizard for first-time setup. It also features a self-update mechanism that checks for new versions via a manifest and downloads APK updates, along with backup/restore functionality for user lists and sources. Architecturally, the app is a monolithic Android application using AndroidX libraries (ViewModel, LiveData, Room, WorkManager) with a service layer (models) and UI layer (Activities/Fragments). External dependencies include OkHttp for HTTP requests, libsu for root shell access, Sentry for telemetry, and Timber for logging. A significant portion of the codebase is vendored native C code (tcpdump/libpcap) used via JNI for packet capture in VPN mode, which introduces maintenance overhead and potential security risks. The app supports Android 8+ and is distributed via F-Droid and its own website. Key entry points include AdAwayApplication (main app class), HomeActivity (dashboard), ListsActivity (manage blocked/allowed/redirected hosts), LogActivity (DNS request log), PrefsActivity (settings), and WelcomeActivity (setup wizard). Data flows involve fetching hosts sources over HTTP, parsing them with regex, storing entries in the database, and applying the blocklist either by writing to /etc/hosts or by intercepting DNS queries through the VPN tunnel.
BigBlueButton is an open-source web conferencing system designed for online learning. It provides real-time audio/video, screen sharing, whiteboard, chat, polling, breakout rooms, and recording/playback. The architecture is distributed and polyglot: a Scala/Akka backend handles meeting logic and state via Redis pub/sub; a Java API layer exposes REST endpoints for meeting creation and recording management; a React frontend with GraphQL subscriptions enables real-time collaboration; Ruby workers process recordings; and a Go GraphQL middleware optimizes subscription delivery. The system integrates with FreeSWITCH for legacy voice and LiveKit for modern WebRTC audio. A plugin SDK allows third-party extensions via customizable UI areas and data consumption hooks. Despite a large feature set and active development, the codebase suffers from significant technical debt due to its multi-language nature, incomplete migrations (e.g., from Meteor to pure React), duplicated logic across frontend and backend, and outdated library versions. Reusable components include the Redis pub/sub framework, GraphQL subscription deduplication hooks, and an annotation export service.
This repository is a curated list (awesome list) of tools, frameworks, and resources for data engineering. It is not a software application or a data research project; rather, it serves as a community-maintained directory of databases, ingestion tools, stream processors, workflow orchestrators, data quality frameworks, and more. The list is organized into categories such as Databases, Data Ingestion, Stream Processing, Batch Processing, Workflow, Data Lake Management, Testing, and Community resources. Each entry includes a link and a brief description. The repository also includes contribution guidelines and CI workflows to maintain list quality. It is widely referenced (over 9,000 stars) and actively updated with new entries via pull requests. The primary value is as a reference for data engineers evaluating tools, not as executable code.
This repository is a curated 'awesome list' aggregating large language model (LLM) resources, not a software application or data pipeline. The primary artifact is a single, massive README.md (written in Chinese) that indexes hundreds of external links to GitHub projects, technical papers, courses, books, models, and tools, organized into roughly 30 categories including data processing, fine-tuning, inference, evaluation, RAG, agents, video/image generation, speech, world models, MCP servers, and small language models. A minimal Jekyll config (_config.yml) enables GitHub Pages rendering of the README. The repo's value is purely informational: it serves as a discovery index for engineers and researchers navigating the LLM ecosystem, and it is actively maintained with very recent resource additions. Curation quality is uneven despite the repo's popularity (~9k stars). Several entries are duplicated (LightRAG, KAG, EvalScope, OpenRLHF, AgentScope, Kiro, Claude Code, VibeVoice, AlayaWorld, WorldWander, simpleRL-reason, and simple_GRPO each appear twice), some internal links use a misspelled repo name ('awesome-LLM-resourses') and will return 404, and the README contains sponsored promotional sections for API resellers. There is no executable code, no tests, and no reusable software components; the only asset is the curated index itself. As a reference resource it is useful and current, but as a codebase it has nothing to extract.
reNgine is a Django-based automated security reconnaissance and attack-surface management platform. It orchestrates 20+ external security tools (Subfinder, Amass, Naabu, Nuclei, FFUF, GoSpider, Dalfox, WAFW00f, EyeWitness, theHarvester, h8mail) via Celery task chains to perform subdomain discovery, port scanning, HTTP crawling, directory fuzzing, OSINT gathering, technology fingerprinting, WAF detection, and vulnerability scanning. Results are parsed from tool outputs (nmap XML, nuclei JSON, dalfox JSON, ffuf JSON), persisted in PostgreSQL, and exposed through a Django REST Framework API plus a jQuery/Bootstrap frontend with server-side DataTables, dashboards, and WeasyPrint PDF reports. The system supports multi-project tenancy, role-based access control (sys_admin, penetration_tester, auditor), scheduled scans via Celery Beat, and deep HackerOne bug-bounty integration for program import, bookmarking, and vulnerability report submission. It also integrates LLMs (OpenAI and local Ollama) for vulnerability description enrichment and attack-surface suggestions. Architecturally it is a monolithic Django application with four feature apps (dashboard, scanEngine, startScan, targetApp, recon_note) and a Docker deployment composed of web, celery, celery-beat, redis, postgres, nginx, and ollama services. The orchestration core, web/reNgine/tasks.py (~3000 lines), composes Celery groups/chords/chains, executes shell commands against external tools, parses their structured output, and persists scan results. The frontend is server-rendered Django templates with heavy inline JavaScript and a supplementary DRF API layer in web/api/views.py. Although it collects and aggregates large volumes of scan-derived data, this is fundamentally an operational security application, not a data-research project. The codebase is actively patched (recent CVE fixes for command injection and XSS) and feature-rich, but carries notable technical debt: an end-of-life Django 3.2 base, old vendored JS plugins (DataTables 1.10.16, Lightbox from 2018), hardcoded container filesystem paths, a monolithic task module mixing orchestration/parsing/persistence, and dead or commented code. The strongest reusable pieces are the RengineTask Celery base class (standardized task logging, caching, and notifications), the dual-provider LLM abstraction with OpenAI/Ollama backends, and a custom server-side datatable filtering language applying operators (=, >, <, !, &, |) across subdomain, endpoint, and vulnerability views. It is best characterized as effective, pragmatic, security-tool engineering rather than clean, academically elegant architecture.
This repository provides curated rule lists for the Shadowrocket iOS proxy application, categorizing tens of thousands of domains and IP ranges into DIRECT (no proxy), PROXY (route through proxy), and REJECT (block) sets. The rules are distributed as Shadowrocket modules that can be loaded independently or combined to implement white-list or black-list routing strategies. The data is aggregated from multiple public sources including dnsmasq-china-list, v2fly domain list, gfwlist, adblock lists, and custom additions for services like TikTok, OpenAI, Telegram, and Google Gemini. The repository also includes a minimal configuration example and factory files that allow users to customize rule sets by appending or excluding specific entries before automated builds. There is no application code; the entire output is data files consumed by Shadowrocket. The repository relies on external CI (not visible in the file tree) to regenerate the modules daily.
This repository is the official project website for the Rime input method engine (δΈε·ι»θΌΈε ₯ζ³εΌζ). It is a static site built with the Zola static site generator, deployed to GitHub Pages via a GitHub Actions workflow. The site provides download links for Rime clients (Weasel for Windows, Squirrel for macOS, ibus-rime for Linux), documentation, a blog, donation information, and an online input method demo using fcitx5-rime.js. It also includes a Python script that automatically fetches the latest release assets from GitHub and updates Sparkle appcast XML files for the Weasel and Squirrel clients, enabling automatic updates. The site features dynamic notices (e.g., commemorative messages, typewriter animations) and Chinese text conversion between simplified and traditional characters. While primarily a content site, it contains well-structured CI/CD pipelines and a reusable release management script.
This repository is a curated, bilingual (Chinese/English) educational resource β effectively a visual knowledge base β for large language model (LLM) and reinforcement learning (RL) concepts, not a conventional software application or data pipeline. The core deliverable is a collection of 100+ original architecture diagrams (editable SVG sources plus large/small PNG exports) spanning LLM internals, SFT/LoRA, DPO, decoding strategies, RL fundamentals, PPO/GRPO policy optimization, RLHF/RLAIF, reasoning-capacity optimization (MCTS, Best-of-N, distillation), and LLM infrastructure topics such as quantization, gradient checkpointing, and RoPE position encoding. The primary entry point is README.md, which embeds each diagram with concise Chinese explanations; src/README_EN.md mirrors the content in English.
This is a React admin dashboard template built with CoreUI, React 19, Vite, Redux, and Chart.js. It provides a comprehensive set of example pages demonstrating CoreUI components, form controls, charts, widgets, authentication flows, and icons. The codebase is well-structured with lazy-loaded routes, a simple Redux store for theme and sidebar state, and reusable layout components (AppSidebar, AppHeader, AppContent). It serves as a starting point for building admin panels rather than a production application. The template includes extensive documentation (ARCHITECTURE.md, DEVELOPMENT.md) and uses JSDoc comments. It is tightly coupled to the CoreUI ecosystem and contains no real backend integration or data fetching logic. The repository is primarily a showcase and scaffold for developers.
Solace Agent Mesh is a production-grade, full-stack platform for building, deploying, and managing event-driven multi-agent AI systems. It comprises a Python backend (FastAPI, Google ADK, SAC), a React/TypeScript web UI (chat, projects, workflows, prompts, scheduled tasks), a Click-based CLI, and a Docusaurus documentation site. The system uses a microservices-like architecture with separate gateway (HTTP/SSE), platform service (model configuration, storage), and agent components, all communicating via the Solace event broker and the A2A (Agent-to-Agent) protocol. Key entry points include the CLI (`solace-agent-mesh`), the web UI (`/chat`, `/projects`, `/workflows`), and the REST API (`/api/v1`). Data flows involve user requests via SSE, agent orchestration with workflow DAGs, tool execution (built-in, MCP, OpenAPI), artifact storage (S3/GCS/Azure/filesystem), and session persistence in SQL databases (SQLite/PostgreSQL/MySQL). External dependencies include a Solace broker, LLM endpoints (LiteLLM), optional databases, and cloud storage services. The repository is marked as deprecated (Development Status 7 β Inactive), with the new version being a desktop application.
This is the original zkSync L2 scaling monorepo (zkSync Lite), implementing a ZK-rollup on Ethereum with low-gas ETH/ERC20 transfers, plus NFTs, swaps, and forced exits. The code is primarily a Rust backend with multiple binaries and services: the core state-keeper/committer (`zksync_core`), REST/JSON-RPC/Web3 API server (`zksync_api`), PLONK prover and witness generator, Ethereum transaction sender, event listener, data-restore tool, and exit-tree generator. It also contains Solidity smart contracts, JavaScript/Rust SDKs, a TypeScript integration test suite, and a large PostgreSQL storage layer with Diesel migrations. In production, the system receives L1 deposits and L2 transactions, validates them in a mempool, builds pending blocks in the state keeper, generates witnesses and proofs, and commits/verifies/executes blocks on Ethereum. The API exposes account, transaction, fee, and NFT endpoints, with WebSocket event notifications. The main external dependencies are Ethereum (via web3/ethabi), PostgreSQL, CoinGecko/CoinMarketCap price feeds, and custom `franklin_crypto`/`rescue`/`jubjub` zero-knowledge circuit libraries. The project is now in a deprecation/sunset phase: zkSync Lite is no longer the active product, and the `exit_tree_generator`/exit-tool paths exist primarily to help users withdraw funds. Architecturally, the monorepo is modular and contains several well-isolated patterns worth studying: a generic `Balancer` for channel-based load distribution, an async shared LRU cache, and generic serde wrappers for hex/BigUint/ratio serialization. These components demonstrate solid Rust engineering, but the repository also carries substantial legacy weight: multiple contract and schema versions, ignored tests, hardcoded development keys, old dependency versions, deprecated testnets, and a custom crypto fork. It is best treated as a reference for the original zkSync architecture or as a base for maintaining a sunset service, not as a codebase to absorb as a whole.
This repository is a curated 'awesome list' of Progressive Web App (PWA) resources, including apps, tutorials, tools, and videos. The primary content is a README.md file that organizes hundreds of PWA-related links by category. The only executable code is a Node.js script (`scripts/check-pwa.mjs`) that validates the listed apps by fetching their URLs and checking for PWA indicators (manifest link, service worker registration). This script runs as a CI job to maintain list quality. The repository is not a software application or data pipeline; it is a documentation/curation project with a supporting automation script. The script demonstrates good engineering practices (concurrent fetching, timeout handling, whitelist for undetectable PWAs) and is reusable for similar validation tasks.
This is a monorepo containing starter templates and final code for the official Next.js Learn courses. It includes multiple independent Next.js applications demonstrating the Pages Router, App Router, data fetching, authentication, SEO optimization, and more. The code is educational, well-structured, and follows modern Next.js patterns (server actions, streaming, suspense, etc.). It is not a production application but serves as a reference implementation for learning. The dashboard example includes a full CRUD invoice management system with PostgreSQL, NextAuth authentication, and Tailwind CSS styling. The basics examples cover static generation, dynamic routes, API routes, and TypeScript. The SEO example demonstrates performance optimization techniques like dynamic imports and lazy loading.
This repository is a curated list (awesome list) of ESLint-related resources, including shareable configs, plugins, parsers, formatters, tools, and tutorials. It serves as a community-maintained index for developers seeking to extend or configure ESLint for various use cases, such as code quality, compatibility, frameworks, security, and style. The primary content is a single README.md file organized into categories, with links to external projects and brief descriptions. The project is not a software application or data pipeline; it is a documentation-focused repository that follows the awesome list convention. It includes a minimal package.json with a test script using awesome-lint to validate the list's formatting and a GitHub Actions CI workflow that runs on pull requests and pushes. The contributing.md outlines guidelines for adding new entries. Despite its simplicity, the repo is actively maintained, with a large number of stars (4766) and forks (270), indicating its value as a reference. It does not contain reusable code components beyond the list itself, but the curation and organization demonstrate good practices for maintaining a community resource.
LLaVA-NeXT is a large multimodal model (LMM) research codebase that extends the LLaVA family to support single-image, multi-image, video, and interleaved tasks. It provides training pipelines for supervised fine-tuning (SFT), direct preference optimization (DPO), and reinforcement learning (PPO, GRPO) with custom vision encoders (CLIP, SigLIP, EVA-CLIP, MLCD) and modular projector/resampler components. The repository also includes a full RL training framework (EasyR1/verl) for large-scale GRPO training using Ray, FSDP, and vLLM, as well as evaluation scripts for video and interleaved benchmarks. While primarily a research codebase with extensive training configurations and experimental scripts, it also contains serving infrastructure (Gradio, SGLang, controller-worker) for deployment. The code is well-structured with reusable vision encoder wrappers, data protocols, and RL algorithm implementations, but suffers from hardcoded internal paths, multiple overlapping RL implementations, and legacy training pipelines that increase maintenance burden.
This repository is the source code for the micro-frontends.org website, an educational resource explaining the Micro Frontends architectural pattern. It contains a Jekyll-based static site with detailed tutorials, along with multiple self-contained example applications (plain HTML, client-side composition, universal composition, and data-fetching) that demonstrate key Micro Frontends concepts. The example code is organized by team (red, blue, green) and uses Custom Elements, Server-Side Includes (SSI), Docker Compose, and Nginx to illustrate how to build independent frontend fragments that can be composed into a cohesive application. The repository serves primarily as a learning tool and reference implementation, not a production-ready framework.
Pingvin Share is a self-hosted file sharing platform designed as an alternative to services like WeTransfer. It provides a full-stack application with a NestJS backend and a Next.js frontend, featuring user authentication (local, OAuth2, TOTP, LDAP), file uploads with chunked transfers, password-protected and expiring shares, reverse shares for receiving files, an administrative panel for managing users and system configuration, and support for multiple storage backends (local filesystem or S3). The application includes virus scanning via ClamAV, email notifications, and extensive internationalization. The backend employs a modular architecture with distinct modules for authentication, user management, share handling, file storage, configuration, and scheduled jobs. Key reusable patterns include an abstracted file storage service (supporting local and S3 providers), a strategy-based OAuth provider interface, and a dynamic configuration service that loads settings from the database with optional YAML file overrides and runtime update notifications. The frontend presents a polished user interface with custom hooks for configuration and user state, reusable input components for timespans and file sizes, and a sophisticated chunked file upload UI with progress tracking and error recovery. Although the original repository has been archived (as of June 2025) with a recommendation to use a maintained fork, the codebase demonstrates solid engineering practices, clear separation of concerns, and several reusable components that could be adapted for similar projects. The Dockerized deployment and comprehensive feature set make it a viable self-hosted solution for file sharing needs.