This repository is the official distribution and testing hub for spaCy's pre-trained NLP models. It does not contain the actual model binaries (which are released as Python wheels via GitHub Releases), but instead houses metadata JSON files for hundreds of model versions across 20+ languages, a comprehensive pytest-based test suite for validating model performance, and shortcut mappings for quick model loading. The metadata files follow a consistent schema that records pipeline components, label inventories, training data sources, accuracy benchmarks, and version compatibility constraints, making them machine-readable for automated model discovery and comparison. The test infrastructure is designed to be reusable for any spaCy model, including custom ones. It uses command-line flags (--model, --lang, --has-parser, etc.) to parameterize tests and conditionally skip components that are not present. The test suite includes corpus-level evaluation against performance thresholds defined in a CSV file, as well as language-specific tests for tagger, parser, NER, and morphologizer components. This allows users to validate that models meet minimum accuracy bars before deployment. While the repository is actively maintained (with model versions up to 3.8.0 and recent commits), it is primarily a release artifact store rather than a training pipeline. Reproducing the models themselves requires access to the original training code and data, which are not included here. However, the metadata and test suite provide a solid foundation for evaluating and comparing spaCy models, and the test patterns can be adapted for other NLP pipelines.
Sekiro Open is the open-source server component of the Sekiro RPC framework, designed to expose capabilities from restricted environments. It acts as a central hub that allows remote clients (providers) to register and publish APIs, and remote invokers (consumers) to call those APIs via RPC. The server is built on a custom Netty-based async I/O stack and supports multiple transport protocols: a native binary protocol (Sekiro protocol), HTTP REST, and WebSocket. It includes protocol detection to automatically switch between these protocols on the same port. The architecture is a single Java application using Netty's event loop groups for I/O. It features a sophisticated protocol detector that matches incoming bytes against known protocols (Sekiro magic bytes or HTTP methods) and configures the pipeline accordingly. Client registration and request routing are handled by dedicated handlers, with load balancing across clients in a group using consistent hashing or round-robin. The server also includes a built-in reverse proxy for serving documentation and other static content. Key components include a single-threaded event loop (Looper) for thread-safe state management, a MurmurHash-based consistent hashing utility for client selection, and an event recording system for debugging asynchronous flows. The codebase is well-structured with clear separation of concerns, though it depends on private libraries for the core protocol and Netty modifications. The repository serves as the open-source demo version of the Sekiro commercial product, providing a functional RPC server that can be used to understand the framework's capabilities. It is primarily useful for developers looking to integrate with the Sekiro ecosystem or understand its internals.
parse-server-example is a reference implementation and starter template for deploying Parse Server, the open-source backend-as-a-service platform, on top of Express. In production it mounts the ParseServer app at a configurable /parse route, exposes the built-in /parse/health endpoint, serves a static demo page at /test, and attaches the LiveQuery real-time subscription server to the same HTTP listener. Configuration is centralized in config.ts with environment-variable overrides for database URI, app ID, master key, and server URL; MongoDB is the required backing store. The server also loads a small cloud-code layer (cloud/functions.ts, cloud/schema.ts) that defines the 'hello' and 'helloAsyncFunction' functions, a beforeSave hook that rejects TestObject saves, and a locked schema definition with per-class permissions. The repository is a monolith by nature, but intentionally minimal: index.ts wires Express, ParseServer, static assets, and LiveQuery; cloud code and schema definitions are cleanly separated into their own modules; and the CI pipeline runs linting plus a Jasmine test suite that boots a real MongoDB via mongodb-runner and exercises cloud functions and schema enforcement against an isolated Parse Server test instance. A multi-stage Dockerfile, semantic-release automation, dependabot, and deployment templates for Heroku, AWS Elastic Beanstalk, Google App Engine, Scalingo, and OpenShift complete the picture. The core codebase is current and well-structured, using Parse Server 9.x, Express 5, and TypeScript 6 with strict linting. However, several peripheral artifacts show drift: the OpenShift template still targets Node.js 10 and MongoDB 3.6 images, app.yaml pins the EOL Node 18 runtime, and public/test.html loads Parse JS SDK 5.3.0 from a CDN while the project itself depends on SDK 8.6.0. The most genuinely reusable asset is spec/utils/test-runner.ts, a self-contained harness for starting, stopping, and cleaning up an isolated Parse Server instance for integration tests.
TLPhotoPicker is an iOS library providing a customizable photo and video picker UI similar to Facebook's picker. It wraps the Photos framework (PHAsset, PHAssetCollection) and offers a configurable grid view with support for smart albums, live photos, video playback, iCloud download, and camera capture. The architecture follows a service-oriented pattern with separate classes for photo library access, selection logic, camera handling, and video playback, all coordinated by a central view controller. The library includes a builder pattern for configuration, async/await support for image loading, and comprehensive delegate callbacks. It is distributed via CocoaPods and Swift Package Manager, targeting iOS 13.0+. The codebase is well-structured but shows some technical drift, notably continued use of the deprecated UIImagePickerController for camera capture instead of the modern PHPickerViewController.
Tranquilpeak is a comprehensive, responsive theme for the Hexo static blog framework. It provides extensive features such as cover images, image galleries with Fancybox, social sharing, sidebar customization, search via Algolia, comment systems (Disqus, Gitment, Gitalk), and a rich set of tag plugins (alerts, highlighted text, images, videos, tabbed code blocks). The codebase is well-organized: SCSS is modular with reusable mixins and variables, client-side JavaScript is structured in isolated modules with clean event handling, and server-side Hexo plugins (filters, helpers, tags) demonstrate solid Node.js patterns. The theme is mature and has been widely adopted, but the repository shows signs of stagnation (no recent commits despite a few open issues), and some dependencies are outdated. Overall, it is a high-quality theme with reusable components, but new development has stalled.
NGBoost is a Python library for probabilistic gradient boosting that produces full predictive distributions rather than point estimates. It implements the Natural Gradient Boosting algorithm described in the research paper (arXiv 1910.03225). The library provides a scikit-learn-compatible API with NGBRegressor, NGBClassifier, and NGBSurvival classes, supporting a wide range of distributions (Normal, Bernoulli, Poisson, Gamma, Weibull, Beta, MultivariateNormal, etc.) and scoring rules (LogScore, CRPScore). A standout feature is the SymPy-based distribution factory (sympy_utils) that automatically derives gradients and Fisher Information from symbolic expressions, enabling easy creation of custom distributions. The architecture is modular: a core boosting loop (ngboost.py) works with pluggable base learners (learners.py), distributions (distns/), and scores (scores.py), combined via a manifold pattern (manifold.py). The library also includes survival analysis with censored scores, partial_fit for incremental learning, and backward-compatible model loading. While primarily a software library, it has strong research roots with experimental scripts, figure generation, and extensive Jupyter notebook examples. The codebase is well-structured and tested, though some deprecated sklearn usage and duplicated documentation content indicate moderate technical drift.
This is a self-hosted social timeline application (moments/ζεε) that allows users to post short updates (memos) with rich media: images, videos, music, links, and Douban (Chinese media database) book/movie references. The architecture is a single Go binary that embeds a Nuxt.js static frontend and connects to a SQLite database. The backend provides a REST API with JWT authentication, supports file upload (local or S3), comment system with email notifications, RSS feed generation, and database backup on version changes. Noteworthy features include automatic database backup with cleanup, image thumbnail generation, Google reCAPTCHA integration, and a calendar-based search for memos. The codebase is well-organized with dependency injection (samber/do), proper route grouping, and data migration scripts. The frontend is a Nuxt 3 SPA with Tailwind CSS and component-based UI. The project is actively maintained with frequent commits and a responsive issue tracker.
This repository is an installable AI-agent skill that generates PowerPoint decks by producing 16:9 slide images with OpenAI's gpt-image-2 model and packaging them into .pptx files. The actual pipeline is CLI-driven: a natural-language or Markdown slide plan is converted into structured JSON (scripts/md_to_plan.py), combined with a selected style or cloned template profile (scripts/runtime_profile.py, scripts/template_analyzer.py), rendered through a robust API wrapper (scripts/image_generator.py), and assembled into a deliverable PPTX (scripts/generate_ppt.py). It also supports optional 'editable' mode, where generated slides are reconstructed into native PowerPoint objects via python-pptx, plus versioned slide editing, rollback, and deterministic real-image overlay with vision-based QA. This makes it a hybrid application/data repository: the dominant character is a tool, but a large fraction of the repo is a curated corpus of 265+ style specification files that encode design tokens, layout routing rules, and machine-readable JSON layout manifests.
WxCleaner is a cross-platform desktop application for detecting and removing duplicate files in WeChat storage directories. It uses a three-stage hashing algorithm (size β partial hash β full hash) to efficiently identify duplicates while minimizing disk I/O. The GUI, built with ttkbootstrap, provides real-time progress visualization, sortable file listings, and safe deletion via system recycle bin. Key features include platform-specific font adaptation, automatic WeChat path detection, and multi-threaded operations to maintain UI responsiveness during scans and cleanup. The architecture separates concerns into reusable modules: scanner.py handles the duplicate detection logic with progress callbacks, platform_utils.py provides cross-platform abstractions for file operations and UI elements, and wx_gui.py manages the Tkinter-based interface. The application supports pausing/resuming deletions, visual distinction between original and duplicate files, and contextual actions like opening file locations. Packaging is handled via PyInstaller with automated GitHub Actions workflows for Windows, macOS, and Linux builds. While the GUI components are application-specific, the core scanning and platform abstraction layers demonstrate strong reusability potential. The codebase shows attention to cross-platform compatibility, user safety (using send2trash instead of permanent deletion), and performance optimization through staged hashing. Dependency management is current, and the project maintains active maintenance with recent commits and release automation.
SDPO (Self-Distilled Policy Optimization) is a framework for training large language models using reinforcement learning algorithms, built upon the verl (Volcano Engine Reinforcement Learning) foundation. The system provides a modular architecture for implementing PPO, GRPO, SDPO, and other RL algorithms with distributed training capabilities via Ray. It integrates with inference engines like vLLM and SGLang, supports multiple model architectures (Llama, Qwen with Megatron optimization), and includes reward modeling for domains like mathematics and coding. The framework features extensible components for reward managers, tools, and agent interactions, with experimental capabilities for fully asynchronous training and multi-turn reasoning. While actively maintained, the system's complexity and extensive dependency ecosystem present moderate technical drift risks.
The KhronosGroup/glTF-Sample-Assets repository contains a comprehensive collection of sample assets for the glTF (GL Transmission Format) specification. The repository is primarily used for testing and demonstrating the capabilities of glTF, including various features such as animations, physics, and materials.
This repository provides a set of Python CLI tools for downloading media (images, videos, GIFs) and text from Twitter/X. It uses Twitter's internal GraphQL API (not the official API) and requires a valid user cookie for authentication. The primary entry point is `main.py`, which downloads media from a specified user's timeline, with options to include retweets, highlights, likes, and time range filtering. Additional scripts handle downloading by hashtag or advanced search (`tag_down.py`), downloading replies to a specific tweet or user (`reply_down.py`), downloading only text tweets (`text_down.py`), and downloading profile information (`profile_down.py`). The tool generates CSV logs and optional Markdown files, supports concurrent async downloads, and includes a caching mechanism to avoid re-downloading. It is a monolithic application with shared utility modules for CSV generation, Markdown generation, caching, and URL handling. The code is functional and well-documented in Chinese, but exhibits some code duplication and tight coupling to Twitter's API structure. It is actively maintained and adapted to Twitter's API changes.
This repository is a desktop application for automating daily tasks in the mobile game Blue Archive. It functions as a Robotic Process Automation (RPA) tool, interacting with Android emulators (via ADB) or the native PC client (via pywin32). The core architecture is a monolithic Python pipeline: a configuration is parsed, a sequence of task objects is executed, and each task interacts with the game by taking screenshots, performing image matching (OpenCV template matching, OCR via pponnxcr), and sending touch/click commands. The application features a web-based GUI built with NiceGUI for configuration and manual control, supports multiple game servers (JP, Global, CN) with per-server asset mappings, and includes a sophisticated user-defined flow editor for creating custom automation scripts. While functionally impressive and actively maintained, the codebase is tightly coupled to the specific game UI, relying heavily on hardcoded pixel coordinates and color ranges, making it brittle to game updates. It also contains a significant data component of hand-crafted grid battle solutions.
FreeOrion is a turn-based space 4X strategy game with a C++ core and extensive Python scripting for game content and AI. The system implements a client-server architecture: a human client using a custom OpenGL GUI toolkit (GiGi), an AI client written in Python, and a dedicated server for multiplayer sessions. Game contentβspecies, technologies, buildings, ship hulls, policiesβis defined in a declarative Python-based DSL (FOCS) and parsed at runtime by C++ parsers. The AI subsystem uses turn-scoped caching, heuristic evaluation, and custom serialization for savegame compatibility. The codebase also includes procedural galaxy generation, a combat resolution engine, and a comprehensive diplomacy and influence system. The primary entry points are `client/human/chmain.cpp` (human client), `client/AI/camain.cpp` (AI client), and `server/dmain.cpp` (server). Data flows involve parsing FOCS scripts into runtime objects, AI order generation via Python modules, and state serialization for persistence and networking. External dependencies include Boost (extensively used for parsing, serialization, signals, and Python integration), Python 3, SDL2, OpenGL, Freetype, OpenAL, and Godot (for the Godot-based client variant). The repository also contains a bundled GUI library (GiGi) that is LGPL-licensed and could be extracted for other OpenGL projects. The codebase is actively maintained with recent commits and a large issue tracker. However, it exhibits medium technical drift due to the coexistence of two parser generations (legacy Boost.Spirit and newer Python-based FOCS parsers), duplicated macro files between production and test directories, and scattered TODOs. The AI subsystem has several incomplete features and hardcoded heuristics. Despite these issues, the core architecture is solid, and several components demonstrate high craftsmanship and reusability.
SmartDNS-rs is a high-performance, cross-platform DNS server and CLI resolver written in Rust. It functions as a local DNS proxy, intercepting and routing DNS queries through a sophisticated middleware pipeline. It supports a wide array of upstream protocols (UDP, TCP, DoT, DoQ, DoH, DoH3) and provides advanced features like ad-blocking, domain-based policy routing, fastest-IP selection via multi-protocol ping (ICMP, TCP, HTTP, HTTPS), and comprehensive caching with prefetch and serve-expired logic. The architecture is centered around a modular middleware chain (`src/infra/middleware.rs`) that processes incoming requests through components for caching, CNAME rewriting, dual-stack IP selection, bogus NXDomain filtering, nftset/ipset integration, hosts file parsing, and dnsmasq lease integration. Configuration is handled by a robust parser using nom combinators, supporting a wide array of directives. The server exposes a REST API for runtime management and includes platform-specific service management for systemd, launchd, Windows services, and OpenWrt. Key entry points include the CLI (`src/cli.rs`) with subcommands for running the server, managing services, testing configuration, and resolving domains. The core server loop is in `src/app.rs`, with protocol-specific listeners in `src/server/`. The project demonstrates strong engineering practices with its middleware pattern, abstract service installer, and efficient domain matching data structures, though it carries some technical debt in the form of patched upstream dependencies and a few unimplemented stubs.
This repository is a performance benchmarking suite for InfiniBand and RDMA over Converged Ethernet (RoCE) networks. It provides a collection of command-line tools (e.g., ib_send_bw, ib_write_lat, ib_read_bw) that measure bandwidth, latency, and message rate for various RDMA verbs (SEND, WRITE, READ, ATOMIC) across multiple connection types (RC, UC, UD, XRC, DC, SRD, Raw Ethernet). The tools follow a client-server architecture where one instance acts as a server and the other as a client, exchanging parameters and data over RDMA or TCP. The architecture is modular, with clear separation of concerns: parameter parsing (perftest_parameters), resource management (perftest_resources), communication setup (perftest_communication), data validation (host_validation, cuda_kernels), and memory backends (host_memory, cuda_memory, rocm_memory, etc.). All core logic is compiled into a static library (libperftest.a) linked by each benchmark binary. The codebase supports a wide range of hardware accelerators (GPUs, NPUs) and advanced features like data validation with SIMD acceleration, encryption, and flow steering. Key entry points are the benchmark main files (send_bw.c, send_lat.c, etc.) which call into the shared infrastructure. External dependencies include the InfiniBand verbs API (libibv, librdma), and optionally CUDA, ROCm, OpenCL, and other vendor libraries. The build system uses autotools with conditional compilation for optional features. The primary data flow involves a client and server exchanging test parameters via a negotiation protocol, then performing a loop of RDMA operations while measuring throughput and latency. Results are printed to stdout or output as JSON. Data validation can be enabled to verify integrity using SIMD or GPU kernels.
This repository provides a file and folder icon theme for Visual Studio Code and VSCodium, using the Catppuccin pastel color palette. The extension includes SVG icons for hundreds of file types, frameworks, and tool-specific configurations, plus folder icons for common directory names. It is implemented as a VS Code extension that dynamically generates themed icon sets based on user preferences (monochrome, specific folders, custom associations). The architecture separates icon definition data (fileIcons.ts, folderIcons.ts) from runtime logic (configuration hooks, theme compilation) and build-time scripts (SVG optimization, flavor generation, preview generation). The code is well-structured TypeScript with functional modules, but the actual executable logic is thinβmost of the repository's value lies in the curated icon associations and design consistency. There are no complex algorithms or reusable libraries; the extension is primarily a configuration-driven asset pipeline with a lightweight VS Code activation handler.
Fiji (Fiji Is Just ImageJ) is a comprehensive scientific image processing platform built on ImageJ. This is a portable application distribution rather than a library, designed for life sciences research with cross-platform support (Windows, Linux, macOS). The codebase implements a monolithic application architecture with a plugin system based on SciJava, supporting multiple scripting languages (Java, JavaScript, Python, Ruby, Clojure, BeanShell, ImageJ Macro). It manages plugin dependencies via Maven-based update sites and provides a launcher system that handles platform-specific native library paths and JVM configuration. The repository demonstrates significant engineering craftsmanship in its cross-platform build automation, legacy compatibility layer for ImageJ 1.x, and service abstraction patterns. However, it carries technical debt through deprecated components (fiji.Main, bin/ImageJ.sh), version drift between pom.xml (2.18.1-SNAPSHOT) and Info.plist (2.0.2), and heavy reliance on shell scripts for platform-specific logic. The codebase is actively maintained with recent commits but has 138 open issues indicating ongoing development challenges.
SparseDrive is a research codebase for camera-based autonomous driving perception and planning, published at ICRA 2025. It implements a unified end-to-end model that jointly performs 3D object detection, multi-object tracking, online HD map vectorization, motion prediction, and ego-motion planning using a sparse scene representation. The system is built on the mmdetection3d framework with custom plugins, and is trained and evaluated exclusively on the nuScenes dataset. The code includes full training pipelines (two-stage: perception first, then motion+planning), data conversion with extended annotations (future trajectories, drive commands, CAN bus ego status), custom CUDA kernels for deformable feature aggregation, and comprehensive evaluation metrics for all tasks. While not a production application, it is a well-structured research implementation that demonstrates non-trivial architectural innovations and provides tools for reproducibility.
Octofriend (also called Octo) is a terminal-based AI coding assistant built with TypeScript and React, running on Bun. Its architecture revolves around a hierarchical agent system: a core 'Trajectory' state machine manages conversational loops, calling LLMs (OpenAI, Anthropic, Grok, local models) through a compiler abstraction layer, executing tools (file editing, shell commands, LSP queries, web search, subagent delegation), and persisting session history to SQLite via Drizzle ORM. The terminal UI is rendered using a custom Rust-based framework (paintcannon) with React components, offering menus, keybindings (including Vim mode), markdown rendering, and interactive tool call display. The codebase is thoroughly tested with unit, integration, and compile-time tests, and includes CI/CD for building standalone binaries across multiple platforms. The project demonstrates strong engineering discipline: a type-safe `Result` monad for error handling, a declarative `ToolBuilder` pattern with custom IR and subagent support, streaming XML parsing, async ownership locks, and a phased schema migration system for the SQLite database. However, some areas show code smell: the main `Trajectory` class is large and tightly coupled, the `app.tsx` UI component is monolithic, and the complex generic types in the IR system may hinder maintainability. A handful of `throw` statements remain despite a stated goal to eliminate them. The training code under `training/` (for fine-tuning JSON correction and fast-edit models) is a secondary concern and may drift from the main application. Hybrid nature: While primarily an application, the repository includes data preparation scripts (Reddit JSON dumps for model training, git diff generators) and a token tracking system, making it tangentially relevant to data engineering workflows. However, these are not the primary focus and are not maintained with the same rigor as the application code.