This repository is a design portfolio and technical showcase for a solar photovoltaic GIS prospecting and forecasting platform. It does not contain a runnable application; instead, it provides architectural documentation (docs/ARCHITECTURE.md, docs/MODULES.md, docs/AI_FORECASTING.md) and three well-crafted code snippets that demonstrate the engineering patterns behind map-based lead identification, AI roof detection service, and PV generation forecasting. The snippets illustrate professional-level software design: input validation, security boundaries, model routing, fallback strategies, and business logic normalization. The repository serves as a reference for architects and engineers evaluating similar systems, but it is explicitly non-reusable for commercial purposes due to the license restrictions.
YesPlayMusic is a third-party desktop and web client for Netease Music (music.163.com), built with Vue 2, Electron, and a self-hosted API server. It reproduces the official client's features (playback, playlists, lyrics, personal FM, scrobbling) while adding cross-platform support (macOS, Windows, Linux, Docker, PWA) and integration with UnblockNeteaseMusic for region-restricted tracks. The architecture is a monolith: a Vuex-driven SPA communicates with Netease's unofficial API via a local proxy, with an Electron shell providing native features (system tray, media keys, MPRIS, Discord Rich Presence). The codebase is in maintenance mode, with the active development shifting to a 2.0 alpha. It suffers from outdated dependencies (Node 14, Vue 2, Electron 13) and several hardcoded workarounds, but remains a functional and feature-rich player for Netease Music users.
This repository is a personal technical blog by the Chinese developer 'ๅด็พฝ' (yayujs), containing a large collection of in-depth JavaScript articles and accompanying demo code. The articles cover core JavaScript concepts such as prototype chains, scope, execution context, closures, 'this' binding, call/apply/bind, new, inheritance, and many utility implementations like debounce, throttle, deep copy, array flattening, currying, partial application, memoization, type detection, and object equality. The demos are standalone HTML/JS files that progressively build up implementations (e.g., 8 versions of a template engine, 7 versions of debounce), making them excellent educational resources. The repository also includes a small VuePress plugin for code copy functionality and examples of module systems (ES6, CommonJS, RequireJS, SeaJS). It is not a production application but a curated set of learning materials. The code is well-structured for teaching purposes, though it lacks modern tooling, automated tests, and CI/CD. Some examples use older JavaScript patterns (var, ES5) and outdated library copies (Underscore 1.8.3, RequireJS 2.3.5), but the core concepts remain relevant.
Open-R1 is a research-focused application for reproducing DeepSeek-R1's training and evaluation pipeline. It provides scripts for supervised fine-tuning (SFT) and group relative policy optimization (GRPO), along with tools for synthetic data generation using teacher models, dataset filtering based on pass rates, and evaluation on reasoning and code benchmarks (AIME, MATH, GPQA, LiveCodeBench). The project is a collection of CLI scripts and Python modules rather than a deployed service. It integrates tightly with Hugging Face Hub, Weights & Biases, and external code execution providers (E2B, Morph, Piston) for reward computation. The codebase exhibits good modularity in its reward functions and code execution provider abstractions, but is now deprecated in favor of upstream TRL. The repo is primarily a training/evaluation application, though aspects like dataset filtering and decontamination make it hybrid with data-research characteristics.
This repository is the companion code for the first edition of 'Hands-on Machine Learning with Scikit-Learn and TensorFlow' (2017). It contains a collection of Jupyter notebooks teaching fundamental and advanced machine learning concepts, covering classification, SVMs, decision trees, ensemble methods, dimensionality reduction, and deep learning with TensorFlow 1.x (including CNNs, RNNs, autoencoders, and reinforcement learning). The code is educational, with step-by-step implementations, inline explanations, and exercise solutions. It is not a production application but a self-contained learning environment, supplemented with datasets (California housing, OECD life satisfaction, MNIST) and a Docker setup for reproducible execution. Significant technical drift exists: TensorFlow 1.x APIs, deprecated scikit-learn imports, and Python 2/3 compatibility shims make the notebooks incompatible with modern environments without substantial rewriting. The README explicitly directs users to the second edition repository for up-to-date code.
Cube UI is a Vue.js 2.x-based mobile UI component library providing reusable components for building mobile/web applications. It offers a comprehensive set of touch-optimized UI elements including buttons, forms, pickers, popups, drawers, and layout components. The library follows Vue plugin patterns with installable components and supports both declarative template usage and programmatic invocation via a create-api pattern. It includes internationalization support, form validation, and integrates with better-scroll for advanced scrolling components. The repository contains source code, build outputs, documentation, examples, and unit tests.
This repository contains the source code for SimpRead (็ฎๆฆ), a browser extension for Chrome and Firefox that provides an immersive reading mode, focus mode, annotation, and later-reading capabilities. The extension extracts article content from web pages, applies customizable typography and themes, and supports exporting to numerous services including Markdown, PDF, EPUB, Kindle, email, and cloud storage (Dropbox, WebDAV, Notion, Evernote, etc.). It includes a rules-based site adaptation engine (defined in `website_list.json`) to handle hundreds of specific websites, a plugin system for user-installed scripts, and a notice/focus system to manage reading sessions. The architecture follows a typical browser extension pattern: a background script (`background.js`) manages storage, OAuth, context menus, and cross-tab communication; content scripts (`contentscripts.js`) inject reading and focus modes into pages; and multiple options pages (`options/`) provide configuration, custom CSS, site management, and notice center. The UI is built with React 0.14.8 and a custom Material Design UI kit (`mduikit`), with heavy use of jQuery for DOM manipulation. State is managed through a central storage service (`storage.js`) that provides reactive reads/writes and versioned migration. External integrations are implemented as service classes with OAuth flows, and a message-action pattern coordinates between isolated script contexts. The codebase demonstrates a strong feature set but suffers from significant technical debt: very old dependencies (webpack 1, React 0.14), deprecated lifecycle patterns, extensive global DOM manipulation mixed with React, hardcoded CDN links and provider secrets, and comments indicating hacky browser workarounds. The site adaptation rule set is large but fragile, relying on exact CSS selectors and inline JavaScript that break when websites change. Despite these issues, the project provides a wealth of reusable patterns, particularly in its custom UI components, notification system, and storage abstraction.
flowchart.js is a browser-side JavaScript library that converts a compact textual DSL into SVG flowcharts rendered via Raphael. The public API is `FlowChart.parse(input)`, which returns a chart object exposing `drawSVG(container, options)`, `clean()`, and `options()`. The DSL defines nodes (`key => symbolType: text`), edges (`a->b`), conditional/parallel branch labels (`yes`, `no`, `path1`-`path3`), inline line-style overrides (`@> {json}`), clickable links (`:>`), click handlers (`:$ functionName`), and flowstate styling suffixes (`|state`). It ships as a UMD bundle with an optional jQuery plugin providing `init`, `setFlowStateByParam`, and `clearFlowState`, plus TypeScript definitions in `types/index.d.ts`. Architecturally it is a cleanly layered monolith: `src/flowchart.parse.js` is a line-based regex state machine that builds the symbol/connection graph; `src/flowchart.chart.js` manages the Raphael paper, bounds, and recursive rendering; a base `Symbol` class in `src/flowchart.symbol.js` handles text layout, attribute resolution, and connector routing; and nine symbol subclasses (`start`, `end`, `operation`, `input`, `output`, `inputoutput`, `subroutine`, `condition`, `parallel`) supply shape-specific anchor points. The most sophisticated piece is the connector router, which detects line-segment intersections and splices cubic Bรฉzier detours to avoid overlaps. Attribute precedence is also well designed: flowstate options override symbol-type options, which override global options. However, the codebase is a webpack 1.x/ESLint 4.x-era ES5 project (engines: Node >= 4.0.0) with only Raphael 2.3.0 pinned as a runtime dependency and no unit tests (`npm test` runs lint only). It carries observable debt: a hardcoded `centerText = false` making a label-positioning branch dead code, a latent variable-shadowing bug in `getNextPath` (uses outer `flowSymb` instead of its argument), a `lineWith` typo, commented-out symbol implementations, and fragile `JSON.parse` on user-supplied line-style text. The release bundle's copyright year is regenerated from the current year at build time, which explains the recent 2026 commit despite no substantive development activity. It is a historically important, once-widely-used library (8.7k stars) that remains functional for its niche, but modern consumers should treat it as legacy and expect to vendor, modernize, or replace it.
Android Debug Database is an Android library that provides a web-based interface for debugging databases and shared preferences in Android applications. When included in an app's debug build, it starts a lightweight HTTP server that serves a web UI allowing developers to inspect databases, run SQL queries, edit data directly, and manage shared preferences. The architecture consists of a core library (debug-db-base) that handles server logic and database interactions, with optional modules for encrypted database support (debug-db-encrypt) and sample applications demonstrating usage. The system uses a client-server model where the server runs inside the Android app and the client is a standard web browser connecting via HTTP to localhost. Key features include support for SQLite databases, Room databases (including inMemory), SharedPreferences, and SQLCipher-encrypted databases, with a responsive web interface built using Bootstrap, jQuery, and DataTables.
This repository is primarily an extensive educational compendium covering mathematics, computer science, and artificial intelligence from first principles to state-of-the-art topics. It contains over 100 markdown files organized into 20 chapters, each with detailed explanations, diagrams, and interactive coding tasks (primarily in Python/JAX). The repo also includes auxiliary tooling: a MkDocs-based documentation site with MathJax and a Pyodide in-browser Python runner that includes a JAX compatibility shim, and a TypeScript MCP (Model Context Protocol) server that provides programmatic access to the compendium content for AI assistants. While the vast majority of the repository is educational content rather than runnable software, the MCP server and interactive runner are functional application components. The compendium is well-structured and current, but the code examples are pedagogical (simplified, not production-ready) and the JAX shim is a fragile polyfill. The project is not a data research pipelineโit contains no datasets, experiment logs, or trained models.
JKVideo is a cross-platform (Android/iOS/Web) Expo React Native application that acts as an unofficial Bilibili client. It browses Bilibili recommendation feeds, searches videos, plays DASH video via a locally generated MPD consumed by react-native-video/ExoPlayer, streams live rooms over HLS, displays video and live danmaku, loads comments, supports QR-code login, downloads videos, and shares them over a LAN HTTP server. The code is organized into expo-router screens, React hooks, Zustand stores, a single API service module, and utility modules; it uses signed WBI requests and maintains Bilibili cookies/CSRF state. The implementation quality is above average for a community project: the service layer includes request deduplication and network-only retries; the video player uses Animated-driven seek bars with video-shot preview thumbnails and quality fallback chains; DASH MPD generation handles Dolby Vision and segment ranges; the download hook pauses on background and resumes on foreground. However, there are no automated tests, some dead/default code remains (App.tsx is not the real entry), a hardcoded Sentry DSN and an exposed EAS Sentry auth token are present, and the LAN-share QR code relies on an external QR API. Live 'real-time' danmaku is actually 1.5-second REST polling of Bilibili's history endpoint, despite README claims of WebSocket. The repository is explicitly deprecated: the Chinese README states Bilibili sent a legal letter and maintenance/Issues/PRs have ceased, even though the last commit is recent. This code is useful as a reference for Bilibili API integration, DASH MPD construction, danmaku rendering, and React Native video-player architecture, but it should not be selected for new production use.
This repository is the unified documentation site for the Lottie animation ecosystem, hosted at lottie.airbnb.tech. It is a static website built with Docsify, serving markdown documentation for Lottie's Android, iOS, Web, React Native, Windows, and After Effects integrations. The repo contains no source code for the Lottie libraries themselves; those live in separate repositories (e.g., lottie-android, lottie-ios). The documentation covers installation, usage, API references, supported After Effects features, community showcase, and contribution guidelines. The site is purely informational and does not implement any application logic or data processing.
This repository is a personal monorepo of Go CLI tools built by nikivdev, primarily revolving around the 'fgo' command (aliased as 'fe'), which provides a fast, interactive command palette for various developer workflows. The toolset includes AI-powered commit message generation via OpenAI, GitHub PR cloning and checkout, port killing, symbolic link management, scratch directory creation, private forking of repos, and integration with macOS-specific tools like osascript and pbpaste. Additional standalone CLIs include 'spec' for converting Markdown specs into Codex execution prompts with optional publishing to unhash.sh, 'ghx' for PR diff retrieval, 'tscp' for Tailscale-based file copy, and 'unite' for unified fuzzy search across multiple CLIs. The repository also contains an experimental Dockerfile layer analyzer library with tests. The codebase is actively maintained but heavily optimized for the author's personal macOS environment, with hardcoded paths and macOS-specific dependencies, making it less portable without modification. The architecture is a flat collection of independent CLI tools sharing common patterns like the go-snap CLI framework and go-fuzzyfinder for interactive selection.
This is an Android application for network traffic capture and diagnostics, functioning as a mobile proxy similar to Fiddler. The core functionality revolves around intercepting HTTP/HTTPS traffic via a locally running BrowserMobProxy instance, capturing requests/responses in HAR format, and providing tools for modifying traffic (via response injection rules), exporting captures, and performing network diagnostics (ping, DNS, traceroute). The architecture follows standard Android patterns with Activities, Fragments, Services, and Utils classes, but integrates deeply with modified versions of Netty, BrowserMob Proxy, and LittleProxy for MITM capabilities. Key entry points include MainActivity (UI launcher), SysApplication (proxy initialization), MyVpnService (system-wide traffic capture via VPN), and LDNetDiagnoService (diagnostic tasks). The application requires manual installation of a CA certificate for HTTPS interception and stores configuration in SharedPreferences. While functional, the codebase exhibits maintenance challenges including reflection-heavy Android version-specific code, complex SSL/TLS management, static state risks, and dependencies on forked libraries that may lag upstream.
This repository is a template for creating ReVanced patches. It provides a Gradle multi-module project structure with a patches module and an extensions module, along with example code for a bytecode patch and an Android extension. The template includes CI/CD workflows for building, testing, and releasing patches using semantic release, as well as issue templates and contribution guidelines. The actual patch logic is not implemented (the example patch contains a TODO), making this a scaffolding repository intended to be forked and customized. The codebase is minimal and well-organized, but lacks any non-trivial logic or reusable components beyond the template structure itself.
This is a Ruby gem that integrates Bootstrap 5.3.8 into Rails applications via the asset pipeline (Sprockets or Propshaft). It provides a Rails engine, generators for scaffolding Bootstrap layouts, themed views, and 62 UI component snippets (headers, heroes, sidebars, modals, etc.), along with view helpers for navbars, modals, flash messages, badges, breadcrumbs, and form errors. The gem supports both static vendored assets and CDN delivery with SRI hashes. Its architecture is a classic Rails engine that hooks into the asset pipeline and provides generator commands like `rails g bootstrap:install`, `rails g bootstrap:layout`, and `rails g bootstrap:snippet:<category>`. Despite being updated to vendor Bootstrap 5.3.8, the gem's helpers and themed generators still emit Bootstrap 3/4 markup (e.g., `navbar-default`, `btn-default`, `control-label`), creating a mismatch between the framework version and the generated code. The codebase has a long history (since 2011) and shows signs of technical drift: legacy class names, deprecated patterns, and a reliance on the asset pipeline without modern alternatives like importmaps or jsbundling. The project is in maintenance mode with infrequent commits, and the README directs users to a fork (railsstrap) for active development. Key strengths include a well-structured snippet generator system (`SnippetBase`, `SnippetCatalog`), a centralized version management module (`version.rb`), and a CDN tag helper that avoids hardcoded URLs. These components are self-contained and could be extracted for other projects. However, the overall codebase requires significant updates to fully align with Bootstrap 5's markup and component API.
This repository is a comprehensive collection of configuration files, JavaScript and Python scrapers, and JSON data for TVBox-like media center applications (e.g., ๅฝฑ่งไป, OKๅฝฑ่ง). It aggregates video content from hundreds of Chinese streaming sites, cloud drives (Aliyun, Quark, 115, etc.), live TV sources, and anime platforms. The core is a set of scraping rules that follow the TVBox ecosystem's conventions, using a templating system (muban) and a shared runtime (drpy2.js) for executing JavaScript-based rules. The repository also includes standalone Python spiders (dr_py compatible) and static JSON configurations for site definitions, search endpoints, and filter parameters. While the code is functional and actively used (2257 stars, 0 open issues), it exhibits significant technical debt: hardcoded API keys, duplicated code across many files, fragile parsing logic dependent on external site structures, and embedded secrets (tokens, cookies). The repository is not a standalone application but a resource library for media aggregation, making it best suited for integration into TVBox variants. It is not a data research project; there are no notebooks, pipelines, or analytical models.
This repository is the build and packaging meta-repo for Hangover, a project that enables running x86 Windows applications on ARM64 Linux by combining Wine with CPU emulators (FEX, Box64). It contains CI workflows (GitHub Actions) that build Wine with ARM64EC support, compile emulator DLLs, and produce Debian/Ubuntu packages. The actual source code resides in submodules (wine, fex, box64). The repository itself is purely infrastructure: Dockerfiles, debian packaging files, and a complex multi-stage CI pipeline. It is actively maintained with regular releases. There are no reusable software components; the value is in the integration and packaging, not in original code.
This repository implements the 'classic' Arbitrum stack, an optimistic rollup L2 scaling solution for Ethereum. It is a multi-language monorepo containing a custom C++ Arbitrum Virtual Machine (AVM) for deterministic execution, a Go-based node (sequencer, validator, RPC server, inbox reader), and Solidity smart contracts for L1-L2 bridging (Inbox, Outbox, Rollup, Challenge, SequencerInbox) and token gateways. The system processes L1 transactions via the SequencerInbox, executes them off-chain on the AVM, posts state commitments to L1, and serves Ethereum-compatible RPC endpoints. Validators can challenge fraudulent assertions through interactive fraud proofs. The codebase is well-structured with clean abstractions for caching, broadcasting, and transaction authentication, but it is explicitly superseded by the Nitro upgrade and no longer actively developed. It demonstrates solid engineering practices for a complex blockchain infrastructure project.
lua-resty-auto-ssl is an OpenResty (nginx + Lua) plugin that automatically issues and renews SSL/TLS certificates from Let's Encrypt (ACME) on the fly. It intercepts the SSL handshake via ssl_certificate_by_lua, checks for existing certificates in shared memory or persistent storage (file or Redis), and if missing, triggers certificate issuance using the dehydrated shell client. Domain validation is handled automatically via HTTP-01 challenges. The plugin supports multiple nginx workers, distributed storage, OCSP stapling, and configurable domain allow/deny policies. It is designed for high-traffic production environments but has been explicitly abandoned by its maintainers, with no active development since 2019. The codebase is well-structured with modular storage adapters, JSON adapters, and locking mechanisms, but relies on external shell processes (sockproc) and the dehydrated script, making it difficult to maintain and prone to issues with modern Let's Encrypt API changes. Given its abandoned status, it is not recommended for new projects; users should consider alternatives like acme.sh, acme-companion, or win-acme.