thehardwarestore.ai

This repository is a comprehensive, curated bibliography and knowledge base for the field of active learning. It organizes hundreds of research papers by conference (ICML, NeurIPS, CVPR, etc.), journal (JMLR, TPAMI, etc.), thesis, and content topic (problem settings, deep active learning, applications, etc.). The repository also provides taxonomies, summaries, and links to papers. It is not a software application or data pipeline; it is a structured reference list intended for researchers and practitioners. The content is entirely in Markdown files, making it trivially reproducible and easy to navigate. The repository is actively maintained with recent commits and a growing star count.

This repository is a collection of Minecraft server metadata, consisting of JSON files and associated images for each server. It includes JSON schemas to define the structure of the metadata, and Python scripts for validating the data and generating an index. The data is used to likely power a server listing website or service. The repository is well-organized with consistent structure across hundreds of servers, and includes documentation and CI workflows.

This repository is a collection of educational Python programs and Jupyter notebooks by Peter Norvig, focused on algorithmic problem-solving, puzzle-solving, and data analysis. It is not a deployable application or a formal research pipeline, but rather a set of self-contained explorations that demonstrate a wide range of programming techniques: constraint propagation, recursive search, dynamic programming, Monte Carlo simulation, n-gram language models, and symbolic computation. The code is well-structured, clearly documented, and often includes inline tests and performance benchmarks. While each notebook or script is independent, many contain reusable utility functions and algorithmic patterns that could be extracted for other projects. The repository includes data files (word lists, n-gram counts, bike ride logs, Sudoku puzzles) that are used as inputs for the explorations. The primary value is educational: it teaches how to think algorithmically and write clean, efficient Python code.

This repository is a community-maintained static directory of remote-friendly tech companies, built with Eleventy v3 and deployed on Netlify. The core dataset consists of ~850+ Markdown files with YAML frontmatter, each representing a company profile with fields like remote policy, tech stack, region, and size. The site transforms this data into an accessible, searchable web interface with tagging, filtering, and SEO optimizations. While primarily a data curation project, it incorporates sophisticated build tooling: design tokens drive Tailwind CSS, custom WebC components provide UI patterns, and a CI pipeline validates contributions and checks for link rot. The repository is hybrid — it is both a curated dataset (data_research) and a static site application (application) — but its primary value lies in the maintained, validated collection of remote work opportunities.

This repository is a curated collection of over 300 terminal color schemes (themes) and a comprehensive conversion toolchain that transforms a single source of truth (YAML + iTerm2 plist files) into configuration files for more than 20 terminal emulators, including Alacritty, Kitty, Windows Terminal, Xresources, Konsole, and many others. The core converter `tools/gen.py` reads source color data, applies WCAG contrast adjustments, and uses Jinja2 templates to generate output files. The repository also includes a terminal-based theme previewer, automated screenshot generation, and WCAG accessibility checks. It is a hybrid project: primarily a data collection with an ETL pipeline for multi-format export, but also contains application-level tools for preview and quality assurance. The codebase is well-organized, with reusable color science utilities (sRGB/P3 conversion, luminance, contrast ratio) and a template-driven generation architecture that can be adapted for other multi-format rendering tasks.

This repository is the canonical data source for the CNCF Cloud Native Landscape, a curated directory of cloud-native projects and products. It contains a single YAML file (landscape.yml) defining thousands of entries with metadata (name, category, logo reference, URLs, crunchbase identifier) and a large collection of SVG logos. There is no application code, pipeline, or notebook. The data is manually maintained via pull requests and validated by a CI workflow that checks the YAML structure. The landscape serves as a reference map for the cloud-native ecosystem and is consumed by the landscape2 rendering tool to generate the interactive website at landscape.cncf.io. Despite being a data repository, it is not a research or analytics project; it is a structured dataset with no transformations, modeling, or analytical outputs.

This repository is a curated collection of over 3400 SVG icons for popular brands, maintained by the Simple Icons project. It is primarily a data repository, with the core assets being the SVG files in `icons/` and the structured metadata in `data/simple-icons.json`. The JSON schema defines brand title, hex color, source URL, guidelines, license, and aliases (including duplicates, localizations, and old names). The repository includes a comprehensive toolchain for managing and validating the icon set: scripts for adding/removing icons, formatting data, and running lint checks (custom linter `ourlint.js`, SVG linting via `svglint`, and JSON schema validation). A JavaScript SDK (`sdk.mjs`) provides utilities for accessing icon data, slug generation, and color normalization. The project is published as an npm package and also served via a CDN. While the primary purpose is data curation, the repository exhibits strong software engineering practices with automated CI/CD (GitHub Actions for release, label sync, issue management), pre-commit hooks, and extensive tests that validate every icon's properties. It is a hybrid of a data collection and a well-engineered toolset for maintaining that collection.

The repository is a data pipeline that generates Shadowrocket configuration files for selective traffic routing, particularly targeting users in Russia who need to bypass censorship while maintaining access to local services. It automates the collection, processing, and formatting of domain and IP lists from various sources into Shadowrocket-compatible rule sets and configuration files. The pipeline fetches data from diverse sources including GitHub repositories, websites (like the Central Bank of Russia), and manually curated lists. It then processes this data through a series of transformations: filtering, formatting, IDN conversion, section-based processing, and DNS resolution, to produce standardized output files that adhere to Shadowrocket's rule syntax. The processed data is used to generate configuration files that define which traffic should go through proxies and which should connect directly. Key reusable components within the pipeline include an IDN decoding script that properly handles internationalized domain names by detecting non-ASCII characters and converting to punycode while preserving original formatting, and a section-based list processor that applies different transformations to file segments based on markers. These components demonstrate non-obvious skill in handling specific data challenges and follow patterns that could be extracted for use in other data processing projects. The pipeline is executed on a daily schedule via GitHub Actions, ensuring the generated configuration files remain up-to-date with the latest domain and IP information from the source feeds. This automation allows users to benefit from continuously improved routing rules without manual intervention.

This repository is a knowledge package designed to create an AI agent skill that embodies Charlie Munger's thinking framework. It doesn't contain executable code but rather curates and structures Munger's mental models, decision heuristics, and communication style into a usable format for AI agent runtimes. The core output is the SKILL.md file, which provides detailed instructions for how an AI agent should adopt Munger's perspective when responding to user queries, including role-playing rules, a response workflow requiring research before answering, and specific guidelines for expressing Munger's characteristic communication style. The repository represents a sophisticated approach to expertise capture and encoding for AI systems. It synthesizes information from over 50 sources including Berkshire Hathaway shareholder meetings, USC/Harvard speeches, interview records, and external criticisms to distill Munger's approach into five core mental models, eight decision heuristics, and a detailed expression DNA. The references/ directory contains the source research materials, demonstrating transparency about the knowledge foundation. Examples/show how the skill works in practice through sample conversations about investment decisions, team management, and content creation. While primarily a knowledge resource, the structure of the SKILL.md file itself offers potential reusability as a template for creating similar 'thinking style' skills for other experts or domains. The systematic approach to encoding expertise through role-playing protocols, mental model collections, decision frameworks, and communication guidelines represents a pattern that could be adapted with domain-specific content substitution for other AI agent skills.

This repository is a community-maintained domain classification dataset used by V2Ray/Project V for geosite routing. It contains over 1,500 plaintext list files organized by company, service, region, or functional category (e.g., ads, AI, education, porn). Each file uses a compact rule language supporting domain, full, keyword, regexp entries, attributes (@cn, @!cn, @ads), and include directives for hierarchical composition. A Go builder (main.go) compiles these lists into a protobuf binary (dlc.dat) with deduplication, redundant subdomain pruning, and optional custom profile assembly. A companion tool (cmd/datdump) reverses the binary back to plaintext for auditing. The repository is primarily a data pipeline: raw curated lists are transformed into a consumable routing artifact. While the Go tooling is essential, the core value lies in the curated data and its modular, attribute-based taxonomy. This hybrid nature (data with application tooling) is typical of domain-specific datasets that require compilation.

This repository is a comprehensive specification and documentation set for the OpenDID (Open Decentralized Identity) framework. It defines standards, protocols, and data models for a decentralized identity system based on W3C DID and VC specifications, with extensions for zero-knowledge proofs. The repository contains no executable code but provides detailed specifications through Markdown documents, GraphML diagrams, PlantUML sequence diagrams, and the OpenDID Schema Definition Language (OSD). It covers the full lifecycle of decentralized identities including DID document management, verifiable credential issuance and presentation, zero-knowledge proof-based verification, wallet management, and secure communication protocols between system components.

This repository provides a JSON dataset of world cities and their administrative divisions (levels 1 and 2) sourced from the GeoNames Gazetteer. The data includes city names, coordinates, country codes, and administrative codes for over 169,000 cities. The repository features automated monthly updates via GitHub Actions that download raw GeoNames data, convert it to JSON format, and validate the output. The data structure enables direct use in geolocation applications, administrative boundary mapping, and demographic analysis without additional processing.

This repository is a collection of syntax theme files (.tet) for the Godot 4.x script editor. It provides 37 distinct themes, including popular variants like Dracula, Monokai, Catppuccin, and others, each defining color schemes for syntax highlighting, UI elements, and editor features. The themes are standalone data files that users can install by copying to Godot's theme directory. There is no application logic, data processing, or code execution—the value lies in the curated color definitions. The repository includes basic metadata (README, license, theme previews) and uses pre-commit hooks for code quality (whitespace fixes).

This repository is a data pipeline that aggregates and consolidates hosts files from 20+ upstream sources (adaway.org, mvps.org, someonewhocares.org, yoyo.org, URLHaus, KADhosts, hostsVN, and others) into unified blocklists for adware, malware, tracking, and optional categories (porn, gambling, fake news, social media). The core pipeline (`updateHostsFile.py`) fetches remote hosts files via HTTP, parses them, deduplicates entries, applies whitelist/blacklist filters, and generates a primary `hosts` file plus 30+ alternate permutations in `alternates/`. Each source has metadata in `update.json` (URL, license, frequency). The `makeHosts.py` script orchestrates full matrix generation of all extension combinations. Output includes stats tracking (`stats.out`, `stats.png`) and auto-generated READMEs via `updateReadme.py`. The repo includes Docker support, GitHub Actions CI (lint, test, multi-Python), CodeQL scanning, and automated dependency updates via Dependabot. Data sources are external URLs; the pipeline is idempotent and designed for scheduled runs.

This repository is a comprehensive benchmarking suite for Rust serialization libraries. It compares over 20 serialization frameworks (e.g., bincode, capnp, flatbuffers, rkyv, prost, serde_json) across four synthetic datasets (log, mesh, minecraft_savedata, mk48) that model realistic data shapes. Benchmarks measure serialization/deserialization speed, payload size, compression (zlib, zstd), and zero-copy access. The codebase includes a deterministic data generation framework via the `Generate` trait, a tooling pipeline (bencher, parser, formatter) for running benchmarks and auto-updating the README with results, and an interactive Yew-based web page for visualizing throughput under bandwidth/CPU constraints. While primarily a research/benchmarking project, it also demonstrates high-quality patterns for conditional compilation, feature-gated code generation, and shared schema definitions across CLI and web frontend.

This repository is a curated collection of traditional Chinese patterns organized as structured open data. It contains 100 high-resolution pattern images accompanied by detailed metadata (in JSON format) and Chinese-language description pages. The data is organized into six thematic categories (Flora, Fauna & Beasts, Geometric, Cloud-Water-Stone, Auspicious Objects, Characters & Composite) and aggregated into machine-readable JSON and CSV formats. Each pattern includes standardized metadata fields for identification, categorization, semantic description, and visual characteristics, along with cryptographic hashes for verification. The project serves as a cultural heritage resource for designers, researchers, and educators interested in traditional Chinese decorative arts.

This repository is a collection of show notes and metadata for the '开源面对面' (Open Source Face-to-Face) podcast series. It contains markdown files for each episode, YAML files for guest archives, and templates used to generate the README and archives pages. The repository uses GitHub Actions with the yaml-readme tool to automatically update the README and archives from the episode data. The content is organized into series (personal growth, job positions, projects, community) and includes detailed show notes with transcripts, guest information, and discussion topics. The repository serves as a structured content repository for podcast metadata and show notes, enabling easy discovery and consumption of the podcast episodes.

This repository is a comprehensive educational resource for data engineering, structured as a handbook and bootcamp. It contains curated learning paths (beginner, intermediate, Databricks AI bootcamp) with lecture materials, homework, and sample datasets. The codebase includes teaching examples of core data engineering patterns: dimensional data modeling (cumulative tables, SCD type 2), fact data modeling (array metrics, datelist int), Apache Spark jobs with unit tests, Apache Flink streaming jobs, and analytical SQL patterns (retention, funnel, grouping sets, growth accounting). It also includes a small Flask server for A/B experimentation and Docker Compose setups for local development. While primarily educational, the SQL scripts and job templates are production-quality and reusable across projects. The repository is actively maintained with pinned dependencies and clear documentation, making it highly reproducible for learners.

This repository from Google DeepMind implements a family of point tracking models (TAP-Net, TAPIR, BootsTAP, TAPNext, TAPNext++, TRAJAN) and the associated TAP-Vid and TAPVid-3D benchmarks. It is primarily a research codebase for tracking arbitrary points in video, with both JAX/Haiku and PyTorch implementations. The code includes training pipelines (Jaxline), evaluation scripts, data generation for synthetic (Kubric) and real datasets (DAVIS, Kinetics, ADT, DriveTrack, Panoptic Studio), and interactive Colab demos. While it has application-like components such as live webcam demos and a VOT challenge tracker, the dominant character is research: the code is organized around benchmarking and model experimentation rather than production deployment. The repository is actively maintained with recent commits and provides extensive documentation for reproducing results.

This repository is a curated, version-controlled taxonomy of cryptocurrency and blockchain ecosystems and their associated GitHub repositories. It is the dataset behind Electric Capital's developer activity reports. The primary artifact is a large collection of timestamped migration files (a custom DSL using commands like `repadd`, `ecoadd`, `ecocon`) that incrementally build a graph mapping ecosystems to repositories with tags. The dataset spans over a decade (2014–2026) and includes hundreds of thousands of repository entries across dozens of ecosystems, from major chains (Ethereum, Bitcoin, Stellar) to niche projects and hackathon submissions. The repository also provides a Python CLI tool (`open-dev-data`) for validating migrations, exporting the taxonomy as JSON Lines or Parquet, downloading the full dataset with resumable transfers and integrity checks, and exploring it locally via DuckDB and an interactive TUI (Harlequin). The codebase is well-structured, with clean abstractions for the data model, timestamp handling, and shell-like command parsing. However, the dataset itself suffers from significant noise—many entries are student hackathon repos, boilerplate forks, or duplicate URLs—which dilutes its signal for research. The curation is manual and not automatically deduplicated. Despite this, the taxonomy and tooling are highly reusable for any domain needing a version-controlled, hierarchically categorized registry of external projects.