This repository contains the backend API for a trading platform, specifically QuantDinger. It handles strategies, indicators, and market data, and has various tests and scripts for ensuring the quality and functionality of the code.
SimpMusic is a production-grade Kotlin Multiplatform music player for Android and desktop (JVM) that streams from YouTube Music's undocumented backend. The codebase is organized around a shared Compose Multiplatform UI module (composeApp), Android entry points (androidApp), a desktop entry point (desktopApp), and optional feature modules for Google Cast, Last.fm scrobbling, and crash reporting. A separately referenced core submodule supplies domain and media-service logic. Internally it uses MVVM with Koin dependency injection, Repository interfaces backed by Room entities and DataStore, StateFlow-based ViewModels, and a large custom Compose component library covering home feed, library management, playlist sync, fullscreen player, lyrics, equalizer, podcasts, Android home-screen widgets, and a desktop mini-player. The app is shipped as a packaged consumer application with Play Store metadata, GitHub Actions, fastlane changelogs, and build variants that swap real integrations for empty stubs in FOSS builds.
xtool is a cross-platform CLI tool and Swift library that enables building, signing, and deploying iOS applications without requiring Xcode. It serves as a replacement for Xcode's build-and-deploy pipeline, supporting macOS and Linux (via Docker). The core library, XKit, provides modules for interacting with Apple Developer Services (certificates, provisioning profiles, devices), implementing Apple's GrandSlam authentication protocol (including Anisette data), code signing via zsign, and device installation via libimobiledevice. The tool also includes a packaging subsystem (PackLib) that resolves SwiftPM dependencies, builds the app, signs it, and bundles it into an .app or .ipa. It supports both free and paid developer accounts and can automatically manage capabilities and provisioning profiles. The architecture is modular, with clear separation between CLI commands (XToolSupport), core library (XKit), and packaging logic (PackLib). It uses modern Swift concurrency (async/await, actors) and dependency injection via swift-dependencies. The codebase includes generated OpenAPI client for Apple's REST API, cross-platform HTTP client abstraction, and utilities for ZIP compression, temporary files, and key-value storage. Examples and integration tests verify functionality. While primarily a developer tool for side-loading and CI/CD for iOS apps, it also exposes the underlying libraries as SwiftPM dependencies for programmatic use. The codebase demonstrates good engineering practices with protocol-oriented design, clean abstractions, and testability. However, it relies on private Apple APIs and a large number of external dependencies, which introduce maintenance risks. The generated OpenAPI client and platform-specific device interactions add fragility, but the core patterns are well-implemented.
This repository is the official release hub for the MiniCPM family of compact large language models (1B to 8B parameters) from OpenBMB. It provides model weights, deployment scripts for 10+ inference backends (vLLM, SGLang, llama.cpp, Ollama, etc.), fine-tuning recipes for 5 frameworks (TRL, LLaMA-Factory, unsloth, etc.), quantization tools (AWQ, GPTQ, BNB), and application demos (survey generation, MCP tool calling, code interpreter). The repo is primarily a model card and cookbook collection rather than a single integrated application; it serves as a developer toolkit for deploying and customizing MiniCPM models in production and edge scenarios. The repository also includes research artifacts such as training datasets (UltraData suite) and technical reports, but the dominant character is applied machine learning engineering.
NapCatQQ is a headless QQ bot framework that integrates with the NTQQ (New Technology QQ) desktop client via native injection and reverse-engineered protocol internals. It implements the OneBot v11 standard protocol, providing HTTP, WebSocket, and SSE network adapters for external bot control, along with a comprehensive web-based management interface (WebUI) for configuration, monitoring, file management, terminal access, and plugin management. The system is organized as a monorepo with over 30 packages, including core QQ protocol interaction (napcat-core), OneBot adapter (napcat-onebot), WebUI backend (Express) and frontend (React), a plugin system, RPC library, protobuf runtime, image size detection, PTY terminal support, and database decryption tools. The architecture is modular but tightly coupled to the NTQQ native wrapper, which is loaded via platform-specific binaries. Key entry points include the shell loader (napcat-shell/napcat.ts) for process management, the framework bootstrap (napcat-framework/napcat.ts), the OneBot adapter initialization (napcat-onebot/index.ts), and the WebUI Express server (napcat-webui-backend/index.ts). Data flows involve receiving QQ events through native listeners, converting them to OneBot events, and dispatching to configured network adapters. Outgoing actions are translated to QQ internal API calls via packet transformers and highway file uploaders. External dependencies include the NTQQ desktop client (required runtime), FFmpeg for media processing, platform-specific native binaries for packet handling and PTY, and various Node.js packages (Express, React, TypeBox, etc.). The project is actively maintained but carries inherent fragility due to its reliance on reverse-engineered QQ internals that may change with QQ updates.
Invoice Ninja is a full-featured open-source invoicing and billing platform designed for small to medium businesses. It handles the complete lifecycle of invoices, quotes, credits, purchase orders, payments, and expenses. The system supports multi-tenant SaaS and self-hosted deployments with per-company database isolation, and integrates with over 20 payment gateways (Stripe, PayPal, Mollie, GoCardless, etc.). It provides client and vendor portals for self-service, along with extensive reporting, CSV export, and e-invoicing capabilities (Peppol, Verifactu, France e-reporting). The application follows a monolithic MVC architecture built on a custom PHP framework (Illuminate) similar to Laravel. It uses an event-driven architecture with domain events and listeners for side effects (email, webhooks, activity logging). Background jobs are queued for async processing. The frontend uses Blade templates, Livewire components, and a separate React app for some admin panels. The API is RESTful with OpenAPI documentation. Key entry points are HTTP controllers under app/Http/Controllers, with request validation classes. Core data flows involve creating entities through factories, persisting via repositories, and triggering events that listeners handle. Payment flows go through abstract payment drivers that encapsulate gateway-specific logic. The system also includes extensive reporting, CSV export, and e-invoicing (Peppol, Verifactu, France e-reporting). External dependencies include a relational database (MySQL/PostgreSQL), Redis for caching and queues, Elasticsearch for search, and various third-party APIs for payment processing, tax calculation (ZipTax), bank integration (Nordigen, Yodlee), email delivery (Mailgun, Postmark, Brevo), and e-invoicing gateways (Storecove, Qvalia).
easytrader is a Python library for automating Chinese stock trading. It supports multiple broker types through three parallel branches: (1) Windows desktop GUI automation using pywinauto for brokers like éķæēģ, åæģ°, å―é, etc.; (2) Web API trading for Xueqiu (éŠį) portfolio rebalancing; (3) Official QMT SDK integration via miniqmt for čŋ æ-based brokers. Additionally, it provides strategy following from JoinQuant, RiceQuant, and Xueqiu platforms, enabling mirroring of simulated trades into real accounts. The architecture uses a factory pattern (easytrader.use() and easytrader.follower()) to create broker-specific trader instances, with abstract base classes (ClientTrader, WebTrader, BaseFollower) implementing common operations like buy/sell/query. A Flask-based remote server mode allows separation of trading client and strategy execution machines. The code is well-structured with clear separation of concerns: config files define broker-specific UI control IDs, strategy patterns for grid data extraction (Copy, Xls) and data refresh (Switch, Toolbar) allow customization without changing core logic. The follower framework includes command expiration, slippage modeling, and multi-user/multi-strategy support. The miniqmt module wraps the proprietary xtquant SDK into the same easy-to-use interface. While the desktop GUI components are Windows-only and tightly coupled to specific broker client binaries, the web-based trader and follower modules are more portable. The library has been actively maintained for years with a large user base (10k+ stars), though some dependencies like pywinauto 0.6.6 and Python 3.6+ show signs of technical drift.
This is a CLI-based web scraper for Sina Weibo (åūŪå) user data and posts. It scrapes user profiles, weibo contents, images, and videos from the mobile version of Weibo (weibo.cn) using a combination of synchronous (requests, lxml) and asynchronous (aiohttp) HTTP requests. The architecture is a pipeline: parsers extract structured data from HTML, downloaders asynchronously fetch media files, and writers persist results to multiple formats (CSV, TXT, JSON, MySQL, MongoDB, SQLite, Kafka, HTTP POST). The spider is driven by a config file (config.json) that controls user id lists, date ranges, filtering, and download options. It supports retry logic, random delays, and global wait periods to avoid rate limiting. External dependencies include requests, lxml, aiohttp, browser_cookie3, and absl-py; optional dependencies add database and message queue support. The codebase is modular with clear separation of concerns, includes unit tests with mocked HTML fixtures, and demonstrates solid engineering practices for a data collection tool.
Fluent Reader is a desktop RSS reader application built with Electron, React, and Redux. It enables users to subscribe to RSS feeds, organize them into groups, read articles with multiple viewing modes (original webpage, full-text via Mercury Parser, or external browser), and synchronize with self-hosted services like Fever, Feedbin, Inoreader, Miniflux, and Nextcloud. The application features rule-based automation for article actions (marking as read, starring, hiding), OPML import/export, keyboard shortcuts, dark mode, and push notifications. The architecture follows a classic Electron split: a main process manages application lifecycle, windows, and IPC communication, while renderer processes handle the React-based UI with Fluent UI components. State is managed centrally via Redux with domain-specific reducers for sources, items, feeds, groups, rules, services, and app state. Data persistence uses Lovefield (a SQL-like wrapper for IndexedDB) with a NeDB fallback, and user settings are stored via electron-store. Key entry points include src/electron.ts (main process), src/index.tsx (renderer root), and src/preload.ts (context bridge for secure main-renderer communication). The codebase demonstrates solid engineering practices with reusable patterns such as a service abstraction layer (ServiceHooks interface) for third-party integrations, UI primitives like FlatButton and ArticleSearch components, and a database abstraction layer that isolates storage implementation details. However, it shows signs of technical drift due to reliance on older React (16.13.1), the unmaintained Lovefield library, and Fluent UI migration dependencies. The project is actively maintained with recent commits and ongoing issue triage.
This repository contains the reconstructed source code of Claude Code (v2.1.88), Anthropic's official terminal-based AI coding assistant. It is a full-featured CLI application built on a custom Ink-based React renderer for terminal UI, with a sophisticated tool system, multi-agent orchestration (swarm/teammate modes), MCP (Model Context Protocol) integration, plugin marketplace, and enterprise management features. The architecture is modular: a core state management layer (createStore, signals), a tool abstraction (buildTool with Zod schemas, permissions, and UI rendering), a permission system with classifier-based auto-approval, and a terminal UI framework with Yoga layout, keyboard/focus management, and animation support. The application supports remote sessions via WebSocket bridge, scheduled tasks (cron), vim mode, computer use (macOS native), and extensive analytics/telemetry via Datadog, GrowthBook feature flags, and first-party event logging. External dependencies include the Anthropic API, AWS Bedrock/Vertex SDKs, MCP SDK, and various cloud provider SDKs. The codebase demonstrates high craftsmanship in state management patterns, tool orchestration, and terminal UI engineering, but also carries technical debt from feature flag proliferation, deprecated sync APIs, and ant-only code paths that complicate external reuse.
Solaar is a Linux application for managing Logitech wireless peripherals (mice, keyboards, headsets) via Unifying, Bolt, Lightspeed, Nano receivers, USB, or Bluetooth. It provides device pairing/unpairing, battery monitoring, LED/RGB control (including per-key), button remapping, profile management, and rule-based automation for device events. The architecture consists of a core device communication library (logitech_receiver), GTK-based GUI, CLI interface, system tray integration, and DBus support for system events. Settings are persisted in YAML files, and the application maintains device state across reconnections via a persister mechanism. The codebase demonstrates solid engineering practices with modular separation of concerns, internationalization support, and comprehensive test coverage.
Certimate is a self-hosted SSL certificate automation tool that manages the full lifecycle of TLS certificates: issuance via ACME protocol, deployment to a vast array of cloud providers (CDN, WAF, load balancers, object storage, hosting panels), and notification via chat bots and email. The system is a single-binary application with an embedded PocketBase backend (SQLite) and a React frontend. The backend is written in a Go-like language and exposes REST APIs for managing certificates, workflows, and settings. The frontend provides a visual workflow designer for creating automation pipelines with nodes for ACME issuance, deployment, upload, monitoring, and notification. Architecture: The application is built around a plugin-style provider architecture. Core interfaces (Deployer, Certmgr, Notifier, ACMEChallenger) are implemented by dozens of providers for different cloud services. A workflow engine executes directed acyclic graphs of nodes, with support for conditions, try/catch, delays, and parallel branches. The system uses PocketBase for persistence, cron-based scheduling, and admin authentication. The UI is built with React, Ant Design, and a flow editor library. Key entry points: main.go (CLI entry), cmd/serve_*.go (server startup), internal/rest/handlers/ (REST endpoints), internal/workflow/engine/ (workflow execution), internal/certacme/ (ACME client), internal/certmgmt/deployers/ (deployment registry), internal/notify/ (notification service). Data flows: User configures access credentials and workflows via UI. Workflows are scheduled via cron and executed by the engine, which calls ACME challengers to issue certificates, then deployers to install them, and notifiers to send alerts. Certificate and workflow state is persisted in PocketBase. External dependencies: PocketBase for storage and admin auth, lego (go-acme) for ACME protocol, dozens of cloud provider SDKs (Alibaba, AWS, Tencent, Huawei, etc.), and various third-party APIs for DNS challenges and deployment. The project also includes trimmed/patched copies of several SDKs to reduce dependency footprint.
This repository is a collection of Android quickstart samples demonstrating various Firebase products. Each sample is a standalone Android application showcasing integration with Firebase services such as Authentication, Realtime Database, Firestore, Cloud Storage, Cloud Functions, Analytics, and more. The samples are provided in both Java and Kotlin, often with parallel implementations, and follow modern Android architecture patterns including ViewModels, Navigation Component, and Jetpack Compose in newer samples. The repository includes shared internal modules for common UI components (chooserx) and custom lint rules (lintchecks) to maintain code quality across samples. The primary purpose is to serve as educational resources for developers learning to integrate Firebase into Android applications.
This repository is a comprehensive educational resource and framework for Context Engineering - the discipline of optimizing how information is structured and presented to Large Language Models within their context window limitations. It moves beyond basic prompt engineering to treat context as a dynamic system that can be engineered for improved AI performance. The repository combines theoretical foundations with practical implementations, offering a structured learning path from basic concepts (atoms, molecules, cells) to advanced applications (neural fields, cognitive tools, multi-agent systems). It provides runnable examples, templates, and reusable components including protocol systems for context operations, multimodal processing frameworks, cognitive architectures, and token budgeting techniques. While primarily educational in nature, the repository contains numerous reusable components and patterns that could be extracted and applied in production AI applications. These include protocol shells for defining context operations, multimodal fusion components, cognitive architecture templates, and specialized agent systems for tasks like research, ethical analysis, and grant writing.
Ladder is a self-hosted HTTP web proxy written in Go, designed for testing and analyzing paywall implementations, content delivery, and access control behavior on modern websites. It intercepts client requests, applies domain-specific YAML rulesets to modify request headers, URLs, and response content (e.g., removing CORS/CSP headers, injecting scripts, rewriting relative URLs), then fetches the target site and returns the modified response. The proxy exposes a web form, a JSON API, a raw HTML endpoint, and a ruleset endpoint, and supports optional FlareSolverr integration for bypassing Cloudflare challenges. It is deployable as a binary, Docker container, or Helm chart, and is configured via environment variables and CLI flags. The architecture is a single Go binary using the Fiber web framework. The main entry point (cmd/main.go) sets up routing, basic auth, and middleware. Core logic lives in handlers/proxy.go, which handles URL extraction, ruleset application, HTTP fetching, HTML rewriting, and FlareSolverr integration. The pkg/ruleset package provides a clean, reusable ruleset loader supporting local files, directories, remote URLs, and gzip-compressed YAML. The codebase is generally well-structured with some global state and a few misnamed test files (e.g., proxy.test.go instead of proxy_test.go) that are not executed by Go's test runner. Despite these minor issues, the project is actively maintained, uses current dependencies, and demonstrates solid engineering practices for a focused tool.
ModelScope is a unified framework for model inference, training, and deployment across computer vision, NLP, audio, multi-modal, and scientific domains. It provides a registry-based architecture where models, pipelines, preprocessors, trainers, and metrics are registered by task and can be instantiated from configuration or directly via Python APIs. The framework integrates tightly with the ModelScope Hub for model and dataset distribution, supporting versioned model IDs and snapshot downloads. Key entry points include the `pipeline()` function for inference, `build_trainer` for training, and CLI tools for cache management and server deployment. The architecture is modular with well-defined base classes (TorchModel, Pipeline, Preprocessor, Metric, Hook) and a configuration system that drives component construction. External dependencies span PyTorch, TensorFlow, HuggingFace Transformers, MMDetection, Diffusers, and numerous domain-specific libraries. The codebase is large and actively developed, but shows signs of technical drift through duplicated research code, skipped tests, and legacy TensorFlow 1.x components.
NSFWJS is a client-side JavaScript library for detecting NSFW (Not Safe For Work) content in images using TensorFlow.js. It provides a simple API to load pre-trained models (MobileNetV2, MobileNetV2Mid, InceptionV3) and classify images into five categories: Drawing, Hentai, Neutral, Porn, and Sexy. The library is designed for both browser and Node.js environments, with backend selection guidance for optimal performance (WebGL, WebGPU, WASM, CPU). The core architecture consists of a lightweight `NSFWJS` class that handles model loading, inference, classification, and disposal, with support for tree-shaking via separate model imports. The repository also includes several demo applications: a full-featured React + Vite demo with Web Worker offloading, camera support, and file drop; a Node.js Express server example; and a minimal HTML/script tag demo. While primarily an application library, it is hybrid in nature as it bundles pre-trained model weights (quantized and base64-encoded) and includes model conversion scripts, making it both a software tool and a model distribution package. The library relies on TensorFlow.js as a peer dependency and uses IndexedDB for model caching in the browser.
This repository provides a CSS library that replicates GitHub's Markdown styling for web content. The main entry point is `github-markdown.css`, which uses CSS custom properties and media queries to automatically switch between light and dark themes based on user system preferences. The library is designed to be included in web projects by linking the CSS file and applying the `markdown-body` class to containers of Markdown-rendered HTML. The project includes multiple theme variants (light-only, dark-only, high contrast, colorblind) generated from a common source, demonstrating a maintainable approach to theme management. The CSS is generated by the `generate-github-markdown-css` tool, ensuring consistency and accuracy to GitHub's styling. The repository also contains a demo `index.html` showcasing the CSS in action with proper layout constraints. The codebase is actively maintained with recent updates, has no external runtime dependencies, and follows modern CSS practices. While the library itself is focused and singular in purpose, the CSS output is comprehensive and non-trivial, capturing numerous details of GitHub's Markdown rendering including syntax highlighting, tables, code blocks, and interactive elements.
IDURAR is a free, open-source ERP and CRM application built on the MERN stack (MongoDB, Express.js, React.js, Node.js) with Ant Design and Redux. It provides modules for invoice management, payment processing, quote generation, customer relationship management, inventory tracking, and financial reporting. The system features multi-language support (44 languages), PDF generation for business documents, role-based access control, and a responsive user interface. The architecture separates concerns with a RESTful API backend and a modular frontend utilizing React, Redux for state management, and Ant Design for UI components.
This is the Locomotive Scroll library (v5), a lightweight JavaScript library for smooth scrolling, parallax effects, viewport detection, and progress tracking on the web. It is built on top of Lenis and uses dual Intersection Observers for performance. The repository is a monorepo containing the core library package (`packages/lib`), a demo site (Astro), a documentation site (Docusaurus), and a landing page (Eleventy/GSAP). The library exposes a data-attribute-driven API (`data-scroll`, `data-scroll-speed`, etc.) and a `LocomotiveScroll` class with lifecycle methods. The architecture is well-structured with clean separation of concerns: Core orchestration, IO wrapper, per-element scroll tracking, and utility math functions. The library is TypeScript-first and outputs multiple module formats (ESM, CJS, UMD). While the core is solid, there are signs of technical drift (older TypeScript version, some duplicated utilities across packages, and a bundle including full Lenis source). The demo and landing page sites are more complex and tightly coupled to GSAP, but the core library is reusable as an npm package.