This repository provides the infrastructure for the Anticipatory Music Transformer, a research project for music generation using autoregressive transformers with anticipatory infilling. The codebase covers the full pipeline: preprocessing of MIDI files (Lakh MIDI dataset) into a compound token representation, tokenization into arrival-time or interarrival-time sequences with optional augmentation for anticipation training, and sampling from trained models using custom generation logic. It also includes scripts for human evaluation reproduction and model benchmarking. While primarily a research codebase for a specific paper, the library components in the `anticipation` package (particularly the conversion, ops, and sampling modules) are well-structured and could be reused in other music tokenization or generation projects. The repository does not include the training loop itself but provides configuration files for use with the Levanter training framework.
This repository is a curated list (awesome list) of resources about post-quantum cryptography. It is not a software application or a data research project. It aggregates links to standards, initiatives, libraries, research papers, and other resources related to PQC. The content is maintained by the community and appears to be regularly updated.
This repository is a comprehensive survey paper on the intersection of knowledge graphs and multi-modal learning. It organizes the literature into two main directions: KG-driven multi-modal learning (KG4MM) and multi-modal knowledge graphs (MM4KG). The survey covers various tasks such as visual question answering, image classification, multi-modal named entity recognition, and knowledge graph completion, among others. Each section includes a list of relevant papers with links to their sources (e.g., arXiv, conference proceedings). The repository is maintained through updates that include adding new papers and fixing links, as evidenced by the recent commit in 2026 and the news items up to 2024-12.
This repository is a community-curated directory of free programming books, tutorials, and learning resources, organized as Markdown files by language and topic. It is not a software application; the repository's content is its data. The primary artifacts are hundreds of Markdown files (e.g., books/free-programming-books.md, books/free-programming-books-<lang>.md) that form a hierarchical index of external links. Supporting infrastructure includes GitHub Actions workflows for link validation (check-urls.yml), RTL/LTR text linting (scripts/rtl_ltr_linter.py), stale PR management, and PR conflict detection. The repo is one of GitHub's most-starred projects and functions as a massive, community-governed reference dataset rather than executable code. The only analytical tool is the RTL/LTR linter, which scans Markdown for bidirectional text issues and is configurable via YAML. The repository demonstrates strong community governance patterns: issue templates, PR templates, automated linting, and stale-issue management. However, it faces inherent challenges of link rot and version staleness across thousands of external URLs. The hybrid nature is notable: it is a data repository (Markdown as data) with software-engineering practices (CI, linting, automation) applied to maintain data quality.
This repository provides a minimal, from-scratch implementation of a Vision-Language Model (VLM) called MiniMind-V, designed for educational purposes and low-resource training. It ingests the ALLaVA-4V dataset (Parquet format with image bytes and JSON conversations) for pretraining (1.27M caption pairs) and supervised fine-tuning (2.9M mixed instruct/caption/text). The architecture follows a LLaVA-1.5 style: a frozen SigLIP2 visual encoder (256×256, 64 patch tokens) projects via a 2-layer MLP into a MiniMind LLM (with optional Mixture-of-Experts). Training freezes the visual encoder and trains only the projector and selected LLM layers, achieving ~3 RMB / 2 hours on a single RTX 3090. The codebase includes training scripts (pretrain and SFT), evaluation, a Gradio web demo, and model conversion to HuggingFace Transformers format. While primarily a research/educational project, it demonstrates a clean, modular VLM pipeline that can be adapted for other multimodal tasks.
This repository is a curated list of markdown resources, including tools, libraries, services, cheatsheets, tutorials, and related markup languages. It is organized into hierarchical sections in markdown files, with the main list in README.md and additional lists in UPCOMING.md, MORE.md, NOTES.md, and COMMERCIAL.md. The repository does not contain any executable code or data processing scripts; it serves as a reference for the markdown ecosystem. The repository is actively maintained, with the most recent commit being very recent (2026-07-31), and shows low technical drift due to ongoing updates. It follows the awesome list convention, providing a structured and discoverable collection of resources for anyone working with markdown.
This repository is a curated, ranked list of open-source Python machine learning libraries, known as 'Best-of Machine Learning with Python'. It functions primarily as a data curation and ecosystem analysis project. The core artifact is a `projects.yaml` file containing structured metadata for over 900 projects, including GitHub identifiers, package manager references, licenses, and category classifications. An automated GitHub Action workflow periodically fetches live metrics (stars, downloads) from GitHub and package registries, recalculates a quality score, and regenerates the `README.md` and changelog files in the `history/` directory. The repository serves as a comprehensive, living directory of the Python ML landscape, tracking trends, identifying dead or inactive projects, and providing a structured, versioned dataset for ecosystem analysis. While it produces a human-readable README, its true value lies in the structured data and the automated curation pipeline, making it a hybrid of a data repository and a content generation system.
This repository is a curated list of awesome Ebitengine frameworks, libraries, and software. Ebitengine is an open-source game library for the Go programming language. The repository contains various categories such as frameworks, GUI, graphics, video, audio, physics, world, resources, scripting, networking, integration, input, testing, games, demos, and applications.
This repository is a curated awesome-list of open-source operations and DevOps tools, organized into 82 categories with 653 entries. It is not a software application; it is a structured dataset of YAML metadata files that are transformed into bilingual README tables via a GitHub Action using Go templates. The data lineage is: contributors add YAML files under items/<category>/<tool>.yaml with fields kind, owner, repo, desc, and desc_en; on push to main, the generator workflow runs the eryajf/yaml-readme action to fetch live GitHub metadata (license, stars, creation/update dates) and render README.md and resources/README-en.md from the provided templates. The repository serves as a discovery resource for engineers evaluating ops tools, answering questions like 'what are the best open-source tools for a given ops category?' and 'what is the license, star count, and last update of a tool?'. It is actively maintained with recent commits, a YAML linting CI, and a clear contribution guide. The reusable assets are the templating pattern and CI workflows, which can be adapted to any curated list or structured-data-to-document pipeline.
This repository is a curated collection of domain blocklists for various categories (ads, malware, porn, etc.) with automated build and maintenance pipelines. It ingests raw domain lists from community submissions and upstream sources, normalizes them, and outputs them in multiple formats (plain text, AdGuard, dnsmasq, etc.) suitable for use in DNS-level content filtering. The project includes a Python package for list processing (normalization, validation, merging), scripts for triaging issues, and GitHub Actions workflows for continuous integration and release management. It serves as a central resource for users of Pi-hole, AdGuard Home, and similar DNS filtering tools. The codebase is well-structured with tests and CI, though the core logic is tightly coupled to the project's configuration and domain-specific rules.
This repository is a comprehensive collection of annotated PyTorch implementations of deep learning papers, spanning transformers, GANs, reinforcement learning, diffusion models, and more. Each implementation includes side-by-side notes explaining the code and underlying concepts, making it an educational resource for understanding and reproducing paper results. The codebase is organized by paper/model type, with standalone experiment scripts, reusable modules, and configuration-driven training loops. Key strengths include clean abstractions for transformer components, a flexible configs system, and extensive coverage of both foundational and modern architectures. However, the project has not seen commits since early 2024, some dependencies are outdated, and certain experiments require large GPU resources or external data not bundled in the repo. While individual components are well-crafted and reusable, the overall collection is best used as a reference and learning tool rather than a production framework.
This repository is a community-driven threat hunting and detection engineering knowledge base rather than a deployable application. It contains 26+ Windows-focused Jupyter notebooks (authored as Jupytext Markdown) that each follow a strict hypothesis-driven methodology: hypothesis, technical context, offensive tradecraft, pre-recorded security datasets, SQL/Pandas analytics, and Sigma rule output. The repo also includes deep Windows internals documentation, MITRE ATT&CK group profiles (CTI), pre-hunt data management guidance, and a small YARA signature set. The dominant character is data_research: the core artifacts are analytical notebooks, structured metadata, and threat intelligence data, with a hybrid component of Python build scripts that generate the Jupyter Book, table of contents, ATT&CK Navigator layers, and evaluation reports.
PayloadsAllTheThings is a curated knowledge base of web application security payloads, bypass techniques, and exploitation methodologies. It is organized by vulnerability type (e.g., SQL Injection, XSS, SSRF, SSTI, File Inclusion) with each category containing a README.md explaining the technique, references to original research, and subdirectories for payload wordlists (Intruder/), exploit scripts (Files/), and diagrams (Images/). The repository also includes methodology guides for Active Directory, cloud pentesting, and privilege escalation. While primarily a static reference, it contains hundreds of standalone exploit scripts (Python, PHP, Ruby, shell) and configuration files (e.g., .htaccess, web.config) that can be directly reused in penetration testing engagements. The content is actively maintained with recent commits and CI/CD workflows, though some payloads reference older CVEs and may require adaptation for modern environments. This is a hybrid resource: a research-oriented payload collection with embedded executable components.
This is the primary game content database for the CMaNGOS World of Warcraft Classic emulator (mangos-classic). It consists entirely of SQL migration files that define creature spawns, waypoints, loot tables, quest scripts, vendor lists, gameobject placements, and creature AI for the vanilla 1.12.1 game client. The repository is a curated dataset derived from multiple sources: official sniffs, web archives (Wowhead, Allakhazam), and cross-ports from other emulator databases (TDB, VDB, vmangos). Updates are applied sequentially via `InstallFullDB.sh` and require the matching mangos-classic core. The data is organized into a flat `Updates/` directory with numbered patches and subdirectories for instance-specific content. Notable patterns include a variable-based GUID allocation system to avoid collisions, extensive use of `spawn_group` for random formation spawns, `creature_spell_list` for data-driven creature AI, and reference loot templates for item pools. While tightly coupled to the MaNGOS schema, the data engineering patterns (idempotent SQL, user-defined variables for GUIDs, incremental updates with version tracking) are well-executed and could be adapted to other game database projects. The ACID subproject provides a standalone EventAI scripting system that is reusable across expansions.
This repository is a comprehensive collection of examples for the **knitr** R package, demonstrating features such as chunk options, hooks, multiple language engines (Python, Bash, C++, etc.), caching, child documents, and output formats (Markdown, LaTeX, HTML, reST, etc.). It serves as both a tutorial for new users and an integration test suite for the knitr package itself. The examples are self-contained, using built-in R datasets (e.g., iris, mtcars, cars) and simple computational tasks. While not a production application or data pipeline, the repo provides a valuable reference for literate programming and reproducible research with R. It is actively maintained by the knitr author and community.
This repository is a large-scale, community-curated collection of free IPTV (Internet Protocol Television) live stream URLs, organized as standardized M3U playlist files by country and platform (e.g., Pluto TV, Samsung TV Plus, local broadcasters). The project functions as a data pipeline: raw stream URLs are contributed via GitHub issues, validated, formatted, and aggregated into categorized playlists (by country, language, category, region, and source) which are deployed to GitHub Pages and a JSON API. Supporting TypeScript scripts handle playlist parsing, stream testing, metadata enrichment from an external database (iptv-org/database), and automated updates via GitHub Actions. While the primary deliverable is the curated dataset, the repository includes a well-structured automation framework that could be adapted for similar data aggregation tasks. The codebase is actively maintained with daily workflows, though the underlying stream URLs are inherently unstable and subject to geo-blocking or link rot.
This repository is a curated, multi-vendor collection of leaked system prompts from major AI chatbots (ChatGPT, Claude, Gemini, Grok, Perplexity, DeepSeek, etc.), captured verbatim from production systems. It serves as a reference corpus for studying AI behavior instructions, safety guardrails, tool definitions, and product positioning across model versions and vendors. The repository also includes Claude Code bundled skills (code review, design-sync, dataviz, deep research) and Claude Design starter components, which are supplementary tooling. While primarily a documentation archive, it contains some well-crafted reusable components such as color palette validation scripts, a design system build/diff pipeline, and a deep research workflow script. The prompts are organized by vendor with version tracking, and the repository is actively maintained with recent updates. However, the tooling scripts lack dependency pinning, and the prompts are time-sensitive snapshots that will drift as products evolve.
This repository provides a comprehensive baseline for person/object re-identification (ReID) using PyTorch. It implements a standard pipeline: data preparation (reorganizing images by identity), training with various backbones (ResNet, DenseNet, Swin, HRNet, etc.) and losses (cross-entropy, triplet, circle, contrastive, etc.), feature extraction, and evaluation (Rank-k, mAP). It also includes re-ranking (CPU and GPU-accelerated via custom CUDA kernels) and adversarial training. The code is well-structured and modular, with many self-contained loss functions and augmentation modules that can be reused in other metric learning projects. However, it is research-oriented: paths are hardcoded, dependencies are not fully pinned, and there is no containerized environment. The repository is actively maintained with support for modern architectures and PyTorch features.
This repository is a curated directory of public APIs, maintained as a human-readable Markdown table in `README.md` and automatically transformed into structured JSON files (`db/resources.json`, `db/categories.json`) via a Node.js generator. The primary data flow is: community contributions (PRs) update the README table → a GitHub Actions workflow runs `scripts/db/update-db.js` on every push to `main` → the script parses the Markdown using `remark-parse`, extracts categories and API entries, normalizes auth and CORS fields, and writes the JSON output back to the repository. The generated JSON serves as a machine-consumable API catalog for developers and tools (e.g., the companion website publicapis.dev). The repository is fundamentally a data_research project: its core value is the curated dataset of 1,800+ APIs with metadata (name, description, auth type, CORS support, category). The only 'application' component is the lightweight generator script and its utility modules, which are well-structured but tightly coupled to the specific Markdown format. There are no tests, no runtime services, and no external data sources beyond the README itself. The dataset is manually curated via pull requests, which introduces maintenance risks (stale links, incomplete metadata) but also ensures human oversight of quality. For reproducibility, an analyst can clone the repo, run `npm install` (dependencies are locked via `package-lock.json`), and execute `npm run build` to regenerate the JSON from the README. The entire pipeline is self-contained and does not require external credentials or data. However, the lack of unit tests means that changes to the parsing logic could silently break the output.
This repository is a curated collection of website-specific 'quirks' (hard-coded behaviors) for password managers, maintained by Apple. It contains structured JSON datasets including password rules (to generate compatible passwords), shared credential relationships (domains that share login backends), change-password URLs, 2FA appending sites, and web browser extension distribution information. The repo also includes reference implementations: a Password Rules language parser (JavaScript) and a regex-to-Password-Rules converter, along with validation and formatting scripts. While primarily a data curation project, the tools are reusable components for any password manager implementation. The data is validated against JSON schemas and linted in CI, ensuring high quality. The repository is actively maintained with frequent contributions from the community.