This repository is a configuration-only bundle for the cryptostorm VPN service, providing OpenVPN client configuration files (.ovpn) organized by cryptographic method (RSA, ECC, Ed25519, Ed448, and post-quantum ML-DSA-87) and server location. Despite having no application source code, the repo is classified as an application because it delivers ready-to-use configuration templates for a network service. The configs are well-structured, with extensive inline comments explaining security choices, cipher performance, and usage instructions. Each .ovpn file follows a consistent template with embedded CA certificates and shared tls-crypt/tls-auth keys. The repository serves as a distribution point for end-users to connect to cryptostorm servers, with a focus on transparency and user education.
PandaWiki is a production-ready, self-hosted AI knowledge base and wiki platform. The actual codebase implements document management with versioned releases, RAG-based Q&A and search, AI-assisted document summarization and editing, multi-source content ingestion (URL, RSS, Sitemap, Notion, Feishu, DingTalk, Confluence, EPUB, Wiki.js, Yuque, Siyuan, etc.), a customizable public landing page builder, analytics, comments, contribution review, and multi-channel bot integrations for WeChat, WeCom, DingTalk, Feishu/Lark, and Discord. It is not a data research repository, but it contains substantial document-ingestion and analytics pipelines that feed the RAG system. The architecture is a full-stack monolith-style application split across a Go backend (Echo + GORM + PostgreSQL + Redis + MinIO/S3 + NATS JetStream), a React admin panel (Vite/MUI/Redux), a Next.js public site, and a pnpm workspace of shared UI/icon/theme packages. The Go backend follows a layered design with handlers, use cases, repositories, middleware, and dependency injection via generated Wire code. A standalone MQ consumer process handles async RAG document updates, crawler exports, and cron-driven statistics aggregation. The public app is served separately from the admin panel, with an embeddable widget and an H5 chat interface. In production, documents are imported through crawler tasks or direct upload, converted to HTML/Markdown, chunked, and upserted into a configurable vector/RAG service. User chat requests rewrite the query, retrieve ranked chunks, and stream LLM responses via SSE with citations. Statistics are rolled up hourly into PostgreSQL. Authentication supports local accounts, JWT sessions, GitHub OAuth, LDAP, CAS, and enterprise SSO. Feature availability is gated by commercial license editions, with a private pro submodule adding enterprise functionality.
This repository is a collection of shell scripts for installing, upgrading, and managing MagicMirror², an open-source smart mirror platform. The scripts automate the setup of Node.js, npm, pm2, and the MagicMirror application on Raspberry Pi and other Linux systems, as well as macOS. They handle tasks such as initial installation, version upgrades, pm2 process management, screensaver disabling, disk cleanup, and switching to browser-over-server mode. The scripts are designed to be executed via curl pipe to bash, ensuring users always run the latest version. While primarily operational, the cleanup.sh script stands out as a well-structured, reusable utility for reclaiming disk space on any system.
This is a Python CLI tool for exporting fitness data from Garmin Connect. It authenticates via OAuth (using the garth library), retrieves activity lists, downloads activity files (GPX, TCX, original FIT, JSON), and writes a configurable CSV summary. The architecture is a single monolithic script (gcexport.py) with a small helper module (filtering.py) for tracking downloaded IDs and excluding activities. It supports session persistence, date filtering, activity type filtering, and subdirectory organization. The code is well-structured with unit tests, CI/CD (GitHub Actions), linting (flake8, pylint, black), and a Dockerfile. However, the project is effectively broken due to Garmin's TLS fingerprinting introduced in March 2026, and the maintainer has indicated they will not work on it further. The codebase itself is clean and demonstrates good Python practices, but its utility is currently zero unless Garmin changes its stance.
fontbm is a cross-platform command-line tool for generating BMFont-compatible bitmap fonts from TrueType/OpenType fonts using FreeType2. The application parses command-line options, renders glyphs, packs them into texture atlases using MaxRectsBinPack, and outputs font metrics in multiple formats (text, XML, binary, JSON) along with PNG texture pages. The architecture is modular with clear separation of concerns: option parsing, FreeType handling, glyph packing, rendering, and output formatting. While the core logic is specific to font bitmap generation, several utility components demonstrate reusable patterns.
This repository is a well-established Python library (`SpeechRecognition`) that provides a unified interface for multiple speech recognition engines, including Google Speech, CMU Sphinx (PocketSphinx), Vosk, OpenAI Whisper (both local and API), Groq, Cohere, and several others. The architecture follows a facade pattern via a central `Recognizer` class, which handles audio capture (microphone, files) and delegates recognition to pluggable backends – each implemented as a standalone function in the `recognizers/` subpackage and attached to the `Recognizer` instance at import time. The library bundles FLAC encoder binaries for audio conversion, offers a CLI tool for model downloads, and includes comprehensive test suites with audio fixtures in multiple formats. While the code is well-structured and features clean abstractions (e.g., `AudioData` for format conversion, `OpenAICompatibleRecognizer` base class), it exhibits some technical drift: bundled FLAC binaries are outdated (v1.3.2 from 2014), it depends on `audioop` (deprecated in Python 3.13+), and several backend APIs are at risk of deprecation. The library is production-grade (v3.17.0) and widely used, but its reliance on hardcoded API keys and legacy workarounds for old Python versions suggests maintenance is ongoing but with moderate lag. Overall, it is a solid, reusable codebase with several components that could be extracted independently.
SeimiCrawler is a Java web crawling framework inspired by Scrapy, built on Spring and JDK 8. It provides a modular architecture with a pluggable downloader interface (Apache HttpClient / OkHttp3), a configurable queue system (local or Redis-based with BloomFilter deduplication), and XPath-based data extraction via JsoupXpath. The framework supports both standalone and Spring Boot deployment, includes an embedded HTTP API for push-based request injection, and integrates with SeimiRender for dynamic page rendering. The codebase demonstrates good engineering practices (interceptor pattern, bean mapping via annotations, retry logic) but has technical debt in outdated dependencies (fastjson, OkHttp) and some duplicated encoding logic across downloaders.
This repository provides 40+ icon pack libraries for WPF (and UWP) applications under the MahApps.Metro ecosystem. The core architecture defines base classes (PackIconControlBase, PackIconDataFactory, converters) that each icon pack extends with auto-generated code: an enum of icon identifiers (e.g., PackIconFontAwesome6Kind), a PackIcon control, markup extensions, and converters. Icon path data is embedded as JSON resources and loaded via a singleton factory. The code is predominantly auto-generated from upstream icon sets (Font Awesome, Material Design, Bootstrap, etc.), leading to a highly repetitive structure across packs. The library is actively maintained with recent commits, CI/CD pipelines, and semantic versioning. While the code is well-organized and functional, the heavy reliance on code generation reduces craftsmanship in the per-pack files; the genuinely reusable components are the base classes in the Core project, which implement icon scaling, flip, rotation, spin animation, and data loading patterns.
The AN2Linux Client is an Android application designed to forward device notifications to a Linux desktop companion server over secure TLS connections. It intercepts notifications via Android's NotificationListenerService, applies user-configured filters (per-app and global), and transmits notification data to configured servers (Wi-Fi, mobile, or Bluetooth) using certificate-based authentication. The architecture combines Android components (Activities, Services, BroadcastReceivers) with modern patterns like ViewModels/LiveData for UI state management, custom preferences for advanced settings, and isolated cryptographic helpers for TLS operations. Key features include foreground service execution to bypass background restrictions, boot-time auto-start, granular notification filtering, and support for multiple connection types with SSID whitelisting for Wi-Fi.
Cloner is a Laravel package that provides a trait for Eloquent models to duplicate models, their relationships, and file attachments. The core functionality resides in the Cloner service class which handles the cloning process, including relationship traversal and file duplication via an adapter pattern. The package supports cloning to the same or different database connections (with limitations for many-to-many relations across databases) and fires events during the cloning process. It is designed as a reusable library for Laravel applications, with a service provider for easy integration.
FBJS is a monorepo containing Facebook's internal JavaScript utility library and associated tooling. It provides a Babel preset for transforming JavaScript with Flow types, ESLint configurations enforcing Facebook's code style, a core utility library with functional programming helpers, data structures, DOM utilities, and cross-browser compatibility helpers. The repository also includes build scripts for dependency checking, module mapping, and test environment setup. Designed primarily for Facebook's internal projects (like React and Relay), it explicitly warns that external consumers may experience instability due to non-semver adherence and API changes. The architecture consists of multiple loosely coupled packages under a monorepo structure. Key entry points include the Babel preset (`babel-preset-fbjs/index.js`), ESLint config (`eslint-config-fbjs/index.js`), core utility index (`fbjs/index.js` which directs users to sub-packages), and build scripts (`fbjs-scripts/index.js`). Data flows involve source code transformation via Babel, linting via ESLint, runtime utility consumption via the fbjs package, and build automation via gulp-based scripts. External dependencies include Babel, ESLint, Jest, Gulp, and Flow, with versions locked in package.json files. Notable reusable components include the Deferred.js promise-like utility, PromiseMap for request deduplication, Heap and CircularBuffer data structures, areEqual for deep equality with circular reference handling, normalizeWheel for cross-browser wheel event handling, and UserAgent/VersionRange for browser detection and version checking. These components are self-contained, demonstrate non-obvious engineering (e.g., circular reference safety, cross-browser normalization), and could be extracted with minimal modification. The codebase shows strong craftsmanship in utility design but is coupled to Facebook-specific tooling and internal conventions, limiting external reuse without adaptation.
Etl-engine is a Java-based ETL (Extract, Transform, Load) library designed for high-performance data synchronization. It provides a lightweight, extensible framework built around three core components: Node (data sources/destinations/transformations), Pipe (thread-safe buffered queues for data transfer), and Dataflow (orchestrator for pipeline execution). The library supports various data sources including JDBC databases (PostgreSQL, MySQL, Oracle, ClickHouse, DuckDB) and file outputs, with built-in capabilities for batch processing, automatic error handling/retry, and detailed logging. The architecture follows a producer-consumer pattern using Java's concurrency utilities, enabling efficient parallel data processing. Sample implementations demonstrate common ETL scenarios like database-to-database transfers, conditional data routing, and value transformation.
This repository provides theme configurations for the Hyprlock screen locker. It includes an example configuration file (hyprlock.conf) and a Tera template (hyprlock.tera) used to generate four color theme files (frappe, latte, macchiato, mocha) via the whiskers tool. The themes define color variables in the format expected by Hyprlock. The repository is lightweight and focuses on delivering ready-to-use themes, with a generation script (justfile) for maintaining the themes. The core functionality lies in the templating system that allows easy creation of new color schemes by defining flavor data.
Wavefront is an enterprise AI middleware platform, open-source alternative to tools like UnifyApps and n8n. It provides a full-stack system for building, managing, and deploying AI agents, chatbots, voice agents, knowledge bases (RAG), and AI-powered workflows. The monorepo includes a Python FastAPI backend with a modular, domain-driven architecture (agents, tools, knowledge base, voice, triggers, auth, API proxy), a React/TypeScript management console, background workers (Celery, stream processors), and the `flo_ai` Python agent framework (LLM wrappers, Arium graph engine, tool system). The platform supports multi-tenancy, RBAC, cloud storage abstractions (GCP/AWS/Azure), and pluggable datasource and authenticator modules. While primarily an application, it incorporates RAG pipelines, image embedding services, and model inference, giving it a hybrid character with strong data engineering elements.
sax-wasm is a high-performance SAX-style XML/HTML/JSX parser written in Rust and compiled to WebAssembly, with JavaScript/TypeScript bindings for Node.js and browsers. It provides streaming parsing of byte streams, emitting events for tags, attributes, text nodes, processing instructions, comments, CDATA, and doctype declarations. The parser is non-validating and focuses on raw speed, using SIMD instructions and optimized grapheme cluster handling. It includes a comprehensive TypeScript API with async generator support for streaming reads from ReadableStream. The repository contains the full Rust source, JS/TS bindings, build tooling (wasm-bindgen, wasm-opt), and extensive test suites covering XML, JSX, Angular templates, edge cases with multi-byte characters, and write-boundary splitting. While the parser is highly optimized and well-tested, the project appears to be in a stale maintenance state with no recent commits (last commit dated 2026-09-13, likely erroneous) and a small community following.
This repository hosts a static documentation site built with MkDocs and the Material theme, which serves as a redirect page for the Data Engineer roadmap. The site consists of a single HTML page that informs users the roadmap has moved and provides a button to access the new roadmap via a Telegram bot. The repository includes the MkDocs configuration, a custom CSS theme, and a small JavaScript enhancement for user interface improvements (scroll-to-top button and clickable site title). The site is built and deployed to GitHub Pages via a GitHub Actions workflow.
This repository implements an OCPP (Open Charge Point Protocol) server for electric vehicle charging stations, supporting versions 1.6, 2.0, and 2.1. It consists of two main applications: OCPP.Core.Server handles WebSocket-based communication with charging stations and provides a REST API for management operations, while OCPP.Core.Management offers an ASP.NET Core MVC web interface for configuring charge points, managing RFID tags, viewing transactions, and sending remote commands. The system uses Entity Framework Core for data persistence with SQL Server and SQLite providers, featuring a plugin architecture for extensions like custom authorization and Azure Service Bus integration. The codebase demonstrates clean separation of concerns with version-specific controllers, middleware patterns, and dependency injection, though it contains some duplication across OCPP version handlers.
This repository contains solutions to Harvard's CS50P (Introduction to Programming with Python) course problem sets, organized by week from Week0 to Week9. Each week features multiple standalone Python scripts that solve specific programming exercises, such as calculating tips, validating license plates, converting time formats, processing CSV files, and generating images or PDFs. The scripts are designed to be run from the command line, typically taking user input via `input()` and producing output via `print()`, with some utilizing external libraries for specialized tasks like emoji conversion, figure generation, or image manipulation. While many scripts are simple and focused on teaching basic programming concepts, several components demonstrate reusable, well-crafted patterns worthy of highlighting. Notable examples include the time-parsing function in Week1/meal.py (converting strings like '7:30 AM' to float hours), the license plate validation logic in Week2/plates.py (enforcing rules on length, character types, and number placement), the CSV transformation script in Week6/scourgify/scourgify.py (splitting 'Last, First' names into separate columns), the Jar class in Week8/jar/jar.py (modeling a container with deposit/withdraw operations), and the time-range conversion function in Week7/working/working.py (converting '9:00 AM to 5:00 PM' to 24-hour format). These components are isolated, self-contained, and could be extracted for reuse in other projects with minimal modification. The repository is actively maintained, with the most recent commit dated 2026-06-04. It relies on a few external libraries (such as `inflect`, `emoji`, `pyfiglet`, `tabulate`, `Pillow`, `validators`, and `fpdf`) for specific functionalities, but the core logic of the highlighted components uses only the standard library. There is no evidence of significant technical debt or outdated dependencies, indicating a low level of technical drift. The codebase serves as an excellent educational resource for beginner to intermediate Python programmers, showcasing practical problem-solving techniques.
OSIN is a Go library implementing an OAuth 2.0 authorization server as defined in RFC 6749, with support for PKCE (RFC 7636). It provides a modular server with configurable storage backends, token generators, and client authentication. The library handles all standard grant types: authorization code, implicit, resource owner password credentials, client credentials, refresh token, and assertion. It also includes non-standard info endpoints. The architecture is centered around a `Server` struct with pluggable `Storage` and token generator interfaces. Key entry points are `HandleAuthorizeRequest`, `HandleAccessRequest`, and `HandleInfoRequest`, which users integrate into their HTTP handlers. The code is well-structured and tested, but the project is in maintenance-only mode with outdated dependencies (e.g., jwt-go v3, jose.v1) and no recent commits. It remains a solid reference implementation for OAuth2 server logic in Go.
Nunjucks is a JavaScript templating engine inspired by Jinja2, designed for both Node.js and browser environments. It provides a full-featured template language with support for inheritance, macros, includes, async rendering, custom filters, tests, and extensions. The library operates via a multi-stage pipeline: lexing, parsing, compiling to JavaScript functions, and runtime execution. It offers multiple loaders (FileSystem, Web, Precompiled) and integrates with Express as a view engine. The codebase is modular and well-structured, though its build tooling and vendored documentation dependencies are outdated. Despite its age, the core library remains functionally current and is widely used.