This repository is an automated IPTV playlist aggregation and publishing pipeline for Chinese-language live television. It continuously fetches dozens of external IPTV source lists, normalizes channel names against a large alias dictionary, filters dead or unwanted streams using manual and auto-generated blacklists, categorizes channels into genres (CCTV, satellite, regional, Hong Kong/Taiwan, VOD, sports), and outputs multiple playlist formats including TXT and M3U variants. The pipeline is driven primarily by main.py and GitHub Actions workflows that run daily, producing files like bbxx365.txt, live.m3u, and a sports page tiyu.html.
This repository is a static website ranking Chinese GitHub developers by follower count, built with Astro and Tailwind CSS. It features two ranking tabs: 'Developers' and 'Markdown Engineers', based on a curated list of users known for documentation/content creation. The site fetches data daily via GitHub Actions using a Node.js script that queries the GitHub API. While primarily a web application, it has a significant data-engineering component in the form of the data collection script, which includes rate limiting, pagination, caching, and deduplication. The frontend implements client-side search functionality and lazy-loaded avatars for performance. The UI is designed with a VSCode-inspired dark theme. The codebase is well-structured, with clear separation of data fetching, utilities, and presentation components. However, the ranking logic and the classification of 'Markdown Engineers' are based on a hardcoded list, which is opinionated and not algorithmic. Overall, the project is a functional and visually polished static ranking site with a robust data pipeline.
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.
This is an investment analysis framework implementing the Turtle Investment Strategy. It provides a modular, multi-agent system for stock analysis that combines quantitative financial analysis, qualitative business assessment, and valuation modeling. The framework collects data from Tushare API (with yfinance fallback), processes financial statements, analyzes annual report PDFs, and generates investment reports. Key features include a two-tier stock screening system, deterministic pre-computation of metrics to prevent LLM calculation errors, and a structured workflow with validation checkpoints. The architecture separates concerns into data collection, processing, analysis, and reporting layers with clear interfaces between components.
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.
RDocumentation 2.0 is the production Next.js frontend for rdocumentation.org, a searchable documentation browser covering every version of every R package published on CRAN and Bioconductor. It is a pages-router Next.js application (Next 14, React 18) deployed as a Docker container on ECS/Kubernetes with CircleCI. The application renders package pages with READMEs, function/topic documentation with syntax-highlighted examples and MathJax-rendered math, download statistics, GitHub repository metrics, collaborator profiles, and search results with pagination. It also implements numerous legacy redirect routes (e.g. campus/help, link/[topic], bare package/topic URLs) that resolve to canonical versioned URLs server-side, plus a local health-check endpoint used by container orchestration. The architecture is a server-rendered UI that delegates all data access to an external backend API at api.rdocumentation.org, supplemented by the GitHub GraphQL API (requiring a GITHUB_TOKEN) for repo star/fork/issue counts and cranlogs.r-pkg.org for monthly download data. Search and autocomplete are client-side, hitting the backend's Elasticsearch-backed search_functions and search_packages endpoints directly. The most interesting engineering resides in the lib/ layer: a custom R-version comparator (R versions are not semver; segments like "1.0.10" vs "1.2-3" need numeric segment comparison), a search query parser that recognizes both stats::lm and lm(stats) scoped-search formats, and client-side deduplication logic that collapses duplicate package/function versions while preserving relevance order — compensating for known quirks in the backend API (identical relevance scores tie-broken by insertion order, latest=1 flag dropping packages with null latest_version_id, function searches lacking topic documents for newest versions). Operational reality is documented honestly in docs/runbook.md: the UI is the most modern component in a larger legacy system. The backend API, worker, and Elasticsearch components date from 2015-2016 and run Node 8; the Depsy collaborator data source has been dead since 2018; and the frontend has minimal error handling when the API is unavailable. The UI code itself is well-structured and cleanly separated between components, lib helpers, and pages, but it ships without unit tests (only Playwright health checks), TypeScript is configured non-strict, and several dependencies lag their ecosystems (ESLint 7, TypeScript 4.9, react-markdown 5's deprecated plugin API, an old recharts beta).
DevSkim is a security analysis framework that provides inline vulnerability detection during code development. It consists of a core .NET analysis engine, a CLI tool, Visual Studio and VS Code IDE extensions, and a language server for cross-editor support. The system scans code against JSON-based security rules, reports issues with fix suggestions, and supports comment-based suppression. Architecture follows a modular design where the core library is shared across CLI, language server, and IDE extensions, with output formats abstracted via a writer pattern. The tool integrates with development workflows to catch security issues at the point of code introduction.
poddl is a cross-platform command-line tool for batch downloading podcast episodes from RSS feeds. It fetches the RSS XML via libcurl, parses it using regex to extract episode titles, URLs, and publication dates, then downloads media files to a specified output directory. The tool supports a variety of options including downloading individual episodes, ranges, newest-first ordering, filename formatting with episode numbers and dates, whitespace handling, and early termination on existing files. The codebase is a monolithic C++11 application split into several classes: Client (HTTP), Parser (RSS parsing), Helper (utilities), FileSystem (cross-platform file operations), and a standalone HtmlCoder for decoding HTML entities. The architecture is clean and modular, with clear separation of concerns, though the use of regex for XML parsing is a known fragility. The repository includes precompiled binaries for Windows and Linux, and the build requires only g++ and libcurl. It is a straightforward, well-structured utility with no external runtime dependencies beyond libcurl.
GraphvizOnline is a client-side Single Page Application (SPA) designed for editing and rendering Graphviz DOT language diagrams directly within the browser. The architecture is purely frontend, utilizing the Ace Editor library for syntax highlighting and `viz.js` (Graphviz compiled to JavaScript/WebAssembly) for rendering. The application manages state via URL parameters and hash fragments, enabling shareable links and presentation modes without backend dependencies. It functions as a self-contained static web tool, relying on bundled dependencies for core functionality.
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.
BasicAirData GPS Logger is a mature Android application for recording GPS tracks, managing them locally, and exporting them in GPX, KML, and TXT formats. The app runs a foreground service (GPSService) to capture location fixes in the background, accumulates points into a Track model with computed statistics (distance, speed, altitude gain/loss, activity estimation), and persists everything in a SQLite database via DatabaseHandler. The UI is organized around a main activity with tabs for live GPS status, current track statistics, and the track list, with support for placemarks, track types, multi-select bulk export/share/delete, and extensive settings for units, filtering, export options, and EGM96 geoid altitude correction.
SYSTEM is an AI-powered macOS automation assistant enabling natural language control of Mac functions through a distributed architecture. It consists of a Tauri-based desktop app for local management, a CLI for setup/diagnostics, a local bridge server executing commands on the Mac, and a Cloudflare Worker serving as the AI agent using Anthropic's Claude. The system emphasizes privacy by keeping processing on user infrastructure, with secure Bearer token authentication between components. The architecture features a modular tool system where each capability (music, reminders, calendar, etc.) follows a consistent interface for easy extension. Communication occurs via HTTP/WebSocket: the UI sends requests to the Cloudflare Agent, which processes natural language with Claude and commands the local bridge. The bridge validates inputs, executes tools (using AppleScript/shell commands), and returns results. Real-time updates use WebSockets for scheduled tasks and notifications. Security is prioritized through command allowlisting, dangerous pattern blocking, and explicit macOS permission requirements. Key reusable components include secure command execution utilities and input validation patterns. The bridge server's validation and command modules isolate security concerns, while the tool interface pattern enables extensibility. The system is actively maintained with a pre-commit hook and low issue count, though distributed components risk drift. Dependencies show no known vulnerabilities (Dependabot Alerts: 0), but reliance on external services (Anthropic, Cloudflare) requires monitoring for API changes.
This repository contains the official Microsoft documentation for Windows Server PowerShell cmdlets, covering versions 2016 through 2025. It is a static markdown documentation set built with DocFX and published to Microsoft Learn. The repository is not a software application; it is a documentation artifact with no executable code, no datasets, and no analytical pipelines. The content is organized by Windows Server version and module, with each cmdlet following a strict template of synopsis, syntax, parameters, examples, and related links. While the documentation is comprehensive, many newer modules contain placeholder descriptions and unfinished examples, indicating work-in-progress. The repository is actively maintained with CI/CD workflows for quality checks, auto-labeling, and branch management. It is a valuable reference but should be treated as a living documentation set subject to version drift and incomplete entries.
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.
Wirebrowser is an Electron desktop application that provides an integrated runtime instrumentation platform for web applications, built entirely on the Chrome DevTools Protocol (CDP). In production, it acts as a unified debugger, memory inspector, network interceptor, and automation runner for JavaScript running in Chromium-based browsers. The application launches a headless or headful Chrome instance via Puppeteer-core, attaches CDP debuggers to multiple pages, and presents a rich GUI (React, Ant Design, Monaco Editor, AG Grid) through an Electron window. The architecture follows a modular event-driven design: core back-end modules (Heap, Debugger, Network, Automation) are loaded by a ModuleManager and communicate with the front-end via custom DOM events and Electron IPC. The debugger module implements a sophisticated hook system that injects user-defined JavaScript callbacks on function entry/leave/return without monkeypatching, using CDP breakpoints and a state machine to serialize asynchronous events. The heap module supports both live object search (via injected QueryObjects) and offline snapshot analysis with object similarity matching (Jaccard/Dice/SimHash) for origin tracing. Key data flows include user-defined automation scripts (Node-side or browser-side) that interact with pages through the WB.Node and WB.Browser APIs, network requests that can be intercepted and modified in real-time, and memory snapshots that are queried for structural matches across multiple snapshots (BDHS). External dependencies are heavy: Puppeteer (bundled Chrome), AG-Grid (community), Monaco Editor, Ant Design, lowdb, and several CDP-specific features that lock the tool to Chromium. The project is primarily targeted at security researchers, reverse engineers, and advanced frontend developers who need introspection beyond standard DevTools.
GeeksBlabla is a Moroccan tech community podcast website built with Astro. It serves as a content hub for podcast episodes (200+ episodes in Darija), blog articles, community projects (BlablaConf, State of Dev, Awesome Morocco), and a team page. The site features a chatbot (BlaBlator) powered by RAG over podcast transcripts using ChromaDB and OpenAI, an episode creation workflow integrated with Notion as a CMS, and YouTube API for metadata. The frontend uses Astro with React interactive islands, Tailwind CSS, and Rive animations for engaging visuals. The architecture is a hybrid of static site generation (Astro static output) with dynamic server actions and API routes deployed to Cloudflare Workers. It includes CI/CD workflows for episode validation, Spotify upload, and YouTube description syncing. While well-structured and feature-rich, it relies on many external services (Notion, OpenAI, ChromaDB, YouTube, Cloudinary, Supadata) and has some code duplication (two identical server action files).
Pipe Viewer is a Perl-based YouTube client providing both a CLI (`pipe-viewer`) and a GTK3 GUI (`gtk-pipe-viewer`). It allows users to search, stream, download, and manage YouTube content including videos, playlists, channels, comments, and captions. The core library `WWW::PipeViewer` abstracts YouTube data extraction via direct web scraping (ytInitialData, protobuf) and the Invidious API, with yt-dlp as a fallback for streaming URLs and comments. The architecture separates network resilience, caching, and format handling into reusable Perl modules (`DiskCache`, `Proto`, `ParseJSON`, etc.), though the CLI and GUI scripts are monolithic and tightly coupled to the library. External dependencies include `mpv`/`vlc` for playback, `yt-dlp` for advanced extraction, and `ffmpeg` for conversion. The project is actively maintained but operates on fragile, unofficial YouTube interfaces, making it susceptible to upstream changes.
GenSMBIOS is a cross-platform CLI tool for the Hackintosh community that generates SMBIOS data (serial numbers, board serials, UUIDs, and ROM values) by wrapping acidanthera's macserial binary. It writes generated values directly into both Clover and OpenCore config.plist files, using OrderedDict parsing to preserve key order and stripping unsupported keys from Clover SMBIOS sections. The tool is distributed as a plain Python script plus Windows (.bat) and macOS/Linux (.command) launchers that locate, download, and even silently install Python when missing. Architecturally it is a menu-driven monolith with small utility modules: a hand-rolled plist library supporting XML and binary formats with Python 2/3 compatibility, a resumable HTTP downloader with live progress/ETA display, a subprocess streaming wrapper, and general CLI helpers. The macserial binary is fetched at runtime from the latest OpenCorePkg GitHub release by scraping HTML rather than using a stable API, and the Python installers similarly scrape python.org pages - functional but brittle. Code quality is solid for a hobbyist project: clean method organization, settings persistence, error handling, and genuinely reusable utility modules. The main weaknesses are the absence of tests, no CI pipeline, no packaging (setup.py/pyproject.toml), lingering Python 2 compatibility shims, and monkey-patching of plistlib internals that has required version-specific workarounds (e.g., Python 3.9's removal of use_builtin_types). Overall it does what it claims well within a niche domain, with medium technical drift.
This repository provides an ARM64 tracing and emulation workflow based on the Unicorn engine, designed to work as an IDA Pro plugin and with standalone replay capabilities. The system allows users to trace ARM64 code execution within IDA, dump memory segments, generate Tenet-compatible logs for analysis, and replay traces offline. Key features include dynamic code simulation, memory dumping, register state tracking, instruction-level logging, and special handling for ARM64-specific instructions like MRS TPIDR_EL0 and AUTIASP. The architecture separates IDA integration (dyn_trace_ida.py) from core emulation logic (unicorn_trace/unicorn_class.py), enabling both interactive tracing within IDA and offline replay of captured traces.
This is a TypeScript library providing a builder API for typesafe Next.js server actions with Zod validation. It is structured as a monorepo with core package `zsa`, React hooks (`zsa-react`), React Query integration (`zsa-react-query`), and OpenAPI exposure (`zsa-openapi`). The core library supports input validation (JSON, FormData, useActionState), procedures for middleware chaining with context propagation, typed error handling via `ZSAError`, configurable retries and timeouts, and client-side hooks (`useServerAction`, `useActionState`). The OpenAPI module generates REST endpoints and OpenAPI specifications from server actions. The codebase is well-organized with fluent builder patterns, comprehensive test coverage (Jest + Playwright), and a documentation site using Fumadocs. However, it is a personal project currently lacking support for Next.js 15, and all packages are pre-1.0 (0.x), indicating potential instability and limited maintenance commitment.