mapcn is a React map component library and documentation site, not a data project. The product is a single-file MapLibre GL JS wrapper (`src/registry/map.tsx`) that exposes composable components such as Map, MapMarker, MapPopup, MapRoute, MapArc, MapGeoJSON, MapClusterLayer, and MapControls. It is distributed as a shadcn/ui registry: users run `npx shadcn add @mapcn/...` and receive copy-paste source code. The accompanying Next.js 16 app is a showcase and docs portal, rendering live examples, code samples, installation commands, and generated LLM-oriented content via routes under `/llm` and `/llms.txt`. Architecturally, the repo combines a library (registry JSON + map.tsx) with an application shell (Next.js App Router, Tailwind CSS v4, shadcn UI components). The map components use React contexts, portals, forwardRef/useImperativeHandle, and MapLibre style expressions to manage markers, popups, routes, arcs, GeoJSON layers, clustering, and hover states. Blocks under `src/registry/blocks/` demonstrate realistic use cases (analytics maps, store locators, logistics networks, uptime monitoring) with hardcoded sample data and external data sources like OSRM routing and Natural Earth GeoJSON. These demo blocks are primarily illustrations, not data pipelines. Maintenance is active, but the codebase has risks: the core map library is a ~3000-line monolith, the distributable JSON registry duplicates source files, and the stack is heavily bleeding-edge (Next.js 16, React 19.2.3, Tailwind v4). No automated tests appear in the repository. Overall it is a polished, effectively structured component library with a strong distribution model, but its craftsmanship is constrained by the single-file monolith and build fragility.
This repository provides educational materials for a hands-on course on building a RISC-V CPU core from scratch. The core is implemented in Transaction-Level Verilog (TL-Verilog) and is designed to run on the Makerchip online IDE. The repository contains a starting-point shell (risc-v_shell.tlv) with a simple test program that sums 1 to 9, and a reference solutions file (risc-v_solutions.tlv) that hides the full implementation. The library (lib/risc-v_shell_lib.tlv) includes reusable, parameterized components such as a register file, data memory, instruction decoder, ALU, and a sophisticated CPU visualization module. The code is modular, uses M4 macros for assembly and configuration, and is well-structured for educational purposes. While the repository is not a standalone application, it effectively demonstrates digital logic design and CPU microarchitecture concepts in a simulation environment.
macroquad is a Rust game engine and graphics library inspired by raylib, providing a simple, immediate-mode API for 2D and 3D rendering, audio, input handling, and UI. The codebase is structured as a monolithic core library with several subcrates (particles, tiled, profiler, physics-platformer, macroquad_macro) that add specialized functionality. The architecture centers on a single-threaded game loop orchestrated by the `#[macroquad::main]` proc macro, with drawing batched via an internal OpenGL abstraction (miniquad). Key data flows include texture and font loading, immediate-mode UI widget rendering, and an experimental scene/coroutine system for game logic. The library is cross-platform (Windows, Linux, macOS, Web, Android, iOS) and emphasizes minimal dependencies and ease of use. While the core is tightly coupled, several subcrates and subsystems are well-encapsulated and demonstrate high craftsmanship.
@fastify/cookie is a Fastify plugin that adds cookie handling capabilities to Fastify applications. It provides automatic parsing of incoming cookies via Fastify hooks and methods to set, clear, and sign cookies on responses. The plugin integrates with Fastify's lifecycle through decorators and hooks, supporting various hook points for cookie parsing (onRequest, preParsing, etc.). It includes robust security features like cookie signing with HMAC, key rotation support, and protection against timing attacks. The implementation follows Fastify plugin best practices and provides both high-level convenience methods and low-level utilities for direct use.
Hugo NexT is a high-quality, elegant Hugo theme ported from the popular Hexo NexT theme. It provides a classic blog layout with four distinct schemes (Muse, Mist, Pisces, Gemini), dark mode support, and extensive customization options. The theme integrates multiple comment systems (Waline, Giscus, Utterances, etc.), search engines (Algolia, local), analytics (51La, Baidu, Google, Busuanzi), and sharing services. It features responsive design, i18n for multiple languages, and a rich set of shortcodes for notes, quotes, bilibili videos, music players, and mermaid diagrams. The architecture follows Hugo's template hierarchy with well-organized partials, shortcodes, and render hooks, making it easy to extend and maintain. The codebase demonstrates strong craftsmanship with clean SCSS organization, modular JavaScript, and comprehensive configuration options.
Mosparo is a self-hosted, open-source spam protection system that replaces CAPTCHA on web forms. It is built as a monolithic Symfony 6.4 application (PHP 8.1+) with Doctrine ORM supporting MySQL, PostgreSQL, and SQLite. The system provides a multi-tenant architecture where each project (website) can define custom spam detection rules (field rules for words, emails, domains, IPs, user agents, etc. and submission rules like random value detection) and security measures (honeypot, minimum time, proof-of-work, request delaying, IP lockout, equal submission blocking). Integration is done via a frontend JavaScript widget that communicates with a verification API. The codebase also includes an administration panel for system settings, user management, GeoIP2 integration, rule package imports, statistics, and self-update capabilities. The architecture follows standard Symfony patterns with controllers, services (helpers), repositories, and Twig templates. The rule engine is extensible via interfaces and is reasonably well-tested at the unit level. The project is actively maintained with a robust CI/CD pipeline and Docker support.
This repository powers https://cheats.rs/, a single-page interactive reference for the Rust programming language. Built with the Zola static site generator, it combines a massive Markdown content file (`content/_index.md`) with custom HTML, SCSS, and JavaScript to deliver a highly interactive cheat sheet. Core features include tabbed panels, memory-layout visualizations (using custom HTML tags like `<datum>` and `<memory-row>`), a day/night mode, an inline code playground, and an X-Ray feedback system that collects per-section sentiment via an external API. The build pipeline is orchestrated by a Gitea Actions workflow that runs Zola, post-processes with PostHTML (inlining assets), generates a PDF with Playwright, and deploys to S3 with Cloudflare cache purging. The codebase is well-structured for its domain, with clean separation of styling (SCSS), client-side logic (vanilla JS), and build scripts. It is actively maintained and demonstrates strong craftsmanship in creating a rich, offline-capable documentation experience, though its single-file content source is fragile and the heavy external dependency on api.cheats.rs poses a risk if the API goes down.
The system-monitoring-center is a Linux desktop application for real-time system resource monitoring and management. It provides a tabbed interface displaying CPU, memory, disk, network, GPU, sensors, processes, services, users, and system information. The application allows users to monitor performance metrics, manage processes and services, and view detailed hardware information through a modular architecture. Built with Python and Tkinter using the Sun Valley theme, the application follows a modular structure where each tab (CPU, Memory, etc.) implements a consistent interface (tab_gui, initial_func, loop_func). Core system data is gathered by the Libsysmon module via /proc, /sys, and system commands (dmidecode, lspci, etc.). The GUI features interactive charts, process/service management capabilities, and supports internationalization across 15+ languages. Configuration is managed through a version-aware system in Config.py. Key reusable components include Common.py for generic GUI utilities (sortable treeviews, search entries, charting canvases) and Config.py for persistent settings management. The application demonstrates good engineering practices with clear separation of concerns, active maintenance, and low technical drift despite Linux-specific dependencies.
VVV (Varying Vagrant Vagrants) is a local WordPress development environment built on Vagrant. It automates provisioning of a Ubuntu-based virtual machine with a full LEMP stack (Nginx, PHP 8.2+, MariaDB 10.11), along with tools like WP-CLI, Composer, Node.js, Memcached, MailHog, and Xdebug. Users define sites and extensions in a YAML config file; VVV clones site templates, generates Nginx configurations, creates databases, and runs setup scripts. Provisioning uses a modular hook system that allows core components (PHP, Nginx, MariaDB, etc.) to register callbacks at specific phases, enabling extensibility via custom extensions and site provisioners. The codebase demonstrates robust error handling, network retries with exponential backoff, atomic file operations, and performance optimizations like apt update caching and command existence caching. While primarily written in Bash with inherent script fragility, the architecture is well-structured, actively maintained, and regularly updated to support current Ubuntu LTS releases and software versions.
BitNet is a high-performance inference framework for 1-bit large language models, specifically the BitNet b1.58 ternary architecture. It provides CPU (x86 with AVX2, ARM with NEON) and GPU (NVIDIA CUDA) backends with custom quantization formats (I2_S, TL1, TL2) that pack ternary weights and use efficient look-up tables and integer matrix multiplication (int8×int2) to achieve significant speedups over full-precision models (1.37–6.17× on CPU). The system is built on a fork of llama.cpp, adding custom GEMM kernels and a Python utility suite for model conversion, embedding quantization, benchmark, and deployment. It includes a CLI interactive mode and an HTTP server for production serving. The repository contains extensive performance benchmarks and configuration tools, making it a production-ready solution for deploying 1-bit LLMs on commodity hardware.
SeekStorm is an open-source, sub-millisecond vector and lexical search engine library and multi-tenancy server written in Rust. It provides a dual-engine architecture combining an inverted index for BM25F lexical search with a leveled IVF index for approximate nearest neighbor vector search, supporting hybrid search via Reciprocal Rank Fusion. The system is designed as a reusable library (`seekstorm` crate) with separate server (`seekstorm_server`), client (`seekstorm_client`), and MCP server (`seekstorm_mcp_server`) crates, enabling both embedded and standalone deployment. Key features include faceted search, geo-spatial search, real-time indexing, spelling correction, query completion, highlighting, and support for multiple data ingestion formats (JSON, NDJSON, CSV, PDF). The codebase demonstrates advanced Rust patterns including SIMD-accelerated similarity computations (AVX2/NEON), memory-mapped I/O, trait-based design, and async concurrency with Tokio. While primarily an application, it incorporates significant research-oriented components such as TurboQuant quantization, n-gram phrase indexing, and extensive benchmark-driven optimizations.
Strelka is a real-time, container-based file scanning system designed for threat hunting, detection, and incident response. It ingests files via gRPC clients (Go oneshot, fileshot, filestream) and orchestrates distributed analysis using a Go frontend, Redis coordinator, and a Python backend running 40+ modular scanners. The system extracts metadata, embedded objects, indicators of compromise (IOCs), and performs recursive extraction on archives, documents, emails, and executables. It integrates with YARA, TLSH, ClamAV, OCR, exiftool, Zeek, Suricata, and external sandboxes. Results are streamed back to clients and can be forwarded to Kafka with S3 redundancy. The architecture follows a microservices pattern with optional Envoy proxying and Kubernetes deployment manifests.
This is a personal Neovim configuration repository for Neovim 0.12+, using a modular Lua setup with the built-in `vim.pack` plugin manager. The architecture is clean: `init.lua` loads core config modules (options, keymaps, autocommands, plugin manager, colorscheme, LSP) and auto-loads per-plugin configurations from `lua/plugins/`. The configuration is production-grade for daily development, featuring LSP integration (TypeScript, Rust, Lua, etc.), fuzzy finding via snacks.nvim, a custom statusline, Mason for tool management, and many quality-of-life plugins. The code is well-organized and demonstrates modern Neovim Lua API usage. It is not a generic library but a specific personal config that can serve as a reference or starting point for other Neovim users.
This is an Ember addon that provides sortable UI primitives as modifiers (sortable-group, sortable-item, sortable-handle). It is a well-crafted, modern Ember v2 addon built with TypeScript and Glint, supporting mouse, touch, and keyboard interactions with full accessibility (ARIA live regions, keyboard reordering, focus management). The architecture is modifier-based: `sortable-group` coordinates a list of items, `sortable-item` handles drag/drop and animation, and `sortable-handle` marks the drag handle. A service manages internal state for multiple groups. It exports test helpers (`drag`, `reorder`) for acceptance testing. The codebase demonstrates strong event-driven design with proper cleanup, throttle/bind for performance, and a scroll-container utility for auto-scrolling during drag. It is not a hybrid; it is purely a front-end library (application).
This repository is the personal blog and knowledge base of digoal, a prominent PostgreSQL DBA and database expert. It contains over a decade of blog posts (2010–2026) covering PostgreSQL internals, performance tuning, database architecture, and related topics, along with a large collection of images, PDFs, and other attachments. The blog is organized by year and month, with each post as a markdown file. The repository also includes a 'skills' directory that defines reusable AI agent skill definitions (SKILL.md files) for various tasks such as fact-checking, stock prediction, bug hunting, and course writing. These skills are structured with agent prompts, reference materials, and supporting scripts, making them extractable and reusable in AI-assisted workflows. The repo is actively maintained and serves as both a reference for database professionals and a library of AI agent capabilities.
This repository contains a collection of shell scripts and supporting files for building Void Linux live ISOs, root filesystem tarballs, platform-specific disk images, netboot tarballs, and an interactive installer. The core scripts (mkrootfs.sh, mkplatformfs.sh, mkimage.sh, mklive.sh, mkiso.sh, mknet.sh) orchestrate XBPS (Void's package manager), dracut, GRUB, syslinux, xorriso, and QEMU user-static to produce bootable images for multiple architectures (x86_64, i686, aarch64, ARM variants) and platforms (generic, Raspberry Pi, Pinebook Pro, GCP, etc.). The repository also includes dracut modules for live environment customization, a dialog-based installer (installer.sh), Packer configurations for cloud and Vagrant images, and GitHub Actions workflows for CI/CD. The code is well-structured with a shared library (lib.sh) handling cross-architecture concerns, binfmt registration, and chroot operations. While tightly coupled to Void Linux's ecosystem, the patterns demonstrated are instructive for anyone building distribution images or live environments.
This repository provides the official documentation, OpenAPI specification, and client libraries for the Congress.gov API (v3), a public REST API that exposes U.S. federal legislative data including bills, amendments, members, committees, hearings, nominations, treaties, and Congressional Record content. The repo is primarily a supporting asset for the API, containing detailed endpoint documentation in Markdown, a machine-readable OpenAPI spec (openapi.yaml/json), and example client implementations in Java and Python. The Python client (cdg_client.py) demonstrates a reusable pattern with dynamic HTTP method dispatch, session management, and optional keyring-based API key storage. The Java client (CDGClient.java) uses java.net.http.HttpClient and a config file reader. The repository does not contain the actual API server implementation; it is a companion repository for developers integrating with the Congress.gov API. The codebase is well-structured, actively maintained (as evidenced by the changelog), and the documentation is comprehensive, though some minor typos exist. The duplicate client directories (java/ and api_client/java/, python/ and api_client/python/) suggest some organizational drift, but the core components are solid.
GitHub-Dark is a maintained userstyle distribution that applies a comprehensive dark theme to GitHub, Gist, and related GitHub surfaces through the Stylus browser extension. Its primary artifact is github-dark.user.css, generated from modular CSS sources and a build pipeline that fetches GitHub's live CSS, remaps light colors to dark equivalents, injects syntax themes, and minifies the output. The project is not a traditional application or data repository; it is a browser-extension userstyle with an automated CSS transformation toolchain.
This repository provides a custom HTML element, `<clipboard-copy>`, that copies text or element content to the clipboard when clicked. Implemented as a web component extending `HTMLElement`, it supports multiple data sources: the `value` attribute, a `for` attribute that references another element by ID (including inputs, textareas, and anchor hrefs), or element text content. The element ensures accessibility by automatically adding `role="button"` and `tabindex="0"` if not present, and handles keyboard events (Enter/Space) for activation. Internally, it uses the modern `navigator.clipboard.writeText()` API when available, falling back to `document.execCommand('copy')` via a temporary hidden node. It also normalizes Unicode whitespace characters (e.g., non-breaking spaces, zero-width joiners) to plain spaces or strips them, ensuring the copied text matches visual expectations. A `clipboard-copy` custom event is dispatched on success, allowing external handlers to provide feedback. The source code is written in TypeScript, is well-structured with clear separation of concerns (clipboard logic in `clipboard.ts`, element definition in `clipboard-copy-element.ts`, and a side-effect module for registration), and includes a comprehensive test suite covering element creation, clipboard operations, shadow DOM contexts, and edge cases like disabled state and Unicode normalization. The project follows GitHub's engineering standards (eslint, prettier, CI via GitHub Actions) and is published as an npm package under `@github/clipboard-copy-element`.
This repository contains two Go CLI tools: `wp2hugo` and `hugomanager`. `wp2hugo` is a production-grade migrator that converts WordPress XML exports into complete Hugo static site structures. It parses WordPress posts, pages, custom post types, taxonomies, comments, and media attachments, then generates Hugo content files (Markdown with YAML front matter), static assets, custom shortcodes (gallery, audio, video, parallax blur, Google Maps, catlist), partials (comments), Hugo configuration, RSS feed with preserved GUIDs, and Nginx redirect rules. It handles a wide range of WordPress shortcodes, Gutenberg blocks, embeds (YouTube, GitHub gists), footnotes, and media download with caching and retry logic. `hugomanager` is a companion tool for post-migration site management: it can analyze Bing backlinks, shrink images/audio, suggest URLs/descriptions/image alt text via OpenAI, convert absolute links to relative, move content with attachments into page bundles, and generate site summaries. The architecture is monolithic but well-modularized into internal packages (wpparser, hugogenerator, mediacache, hugomanager sub-packages). The codebase demonstrates strong Go engineering practices: comprehensive linting, CI/CD with goreleaser, unit tests, and structured logging. It is actively maintained with frequent releases and community adoption (25+ sites migrated).