This repository is an official Arduino C++ library, not a standalone application or service. In production it is compiled into Arduino sketches to drive Hitachi HD44780-compatible alphanumeric LCD modules over parallel GPIO. The code supports 4- or 8-bit data-bus modes, an optional RW pin, multi-row displays via DDRAM row offsets, 5x8/5x10 character fonts, cursor/blink/display control, scrolling, text direction, autoscroll, and up to eight custom CGRAM glyphs. The actual implementation is only src/LiquidCrystal.cpp and src/LiquidCrystal.h; the remaining files are examples, documentation, and CI workflows. Architecture is a single class inheriting from Arduino's Print, exposing constructors for common pin configurations, begin(cols, rows, charsize), and high-level methods. Data flow is layered: public commands call command() or write(), which call send(); send() either writes a full byte or splits it into high/low nibbles, and pulseEnable() generates the timing-critical enable pulses through digitalWrite/delayMicroseconds. There are no external dependencies beyond the Arduino core headers (Arduino.h, Print.h). The repository is actively maintained with GitHub Actions for Arduino lint, example compilation across AVR/SAM/SAMD/Mbed boards, spell checking, and Dependabot. The code is stable and battle-tested but shows its age in minor ways: an unused _initialized member, a redundant begin() call from the constructor, and non-const createChar signatures. Technical drift is low because the HD44780 protocol is fixed hardware and the Arduino APIs used are stable. It serves as a reference implementation for similar bit-banged parallel device drivers and is directly reusable as an Arduino Library Manager dependency.
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.
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 is the `express-jwt` npm package, a widely-used Express.js middleware for validating JSON Web Tokens (JWTs). The core function `expressjwt(options)` returns a middleware that extracts the JWT from the request (defaulting to the Authorization Bearer header), decodes it, verifies its signature using a provided secret or async callback, checks standard claims like audience and issuer, and optionally checks token revocation. The decoded payload is attached to `req.auth`. The middleware supports CORS preflight handling and integrates with `express-unless` for conditional skipping. It is a focused, well-structured library with clean TypeScript types and a simple architecture. The code is actively maintained by Auth0 with automated CI/CD for releases and testing across multiple Node.js versions. The primary reusable component is a generic deep property setter utility.
This repository is the official archive and static site for 'θεΈζΊ iOS ε¨ζ₯' (Senior Driver iOS Weekly), a long-running curated newsletter for iOS developers. The project spans from 2018 to the present (2026) and contains over 380 weekly issues stored as structured Markdown files. While the core content is a curated list of articles, tools, and news, the repository also includes a build pipeline and a single-page application (SPA) that generates a searchable, full-text archive deployed to GitHub Pages. The architecture is a hybrid of content repository and static site generator: the `scripts/build-index.js` script parses the Markdown files, extracts metadata (sections, recommenders, reading time), and builds a search index using MiniSearch with CJK tokenization. The `docs/` directory contains the resulting SPA (`app.js`, `index.html`) and vendored libraries. The CI workflow (`.github/workflows/pages.yml`) automates building and deploying. The project is community-driven, with contributions submitted via GitHub Issues. It is actively maintained with recent updates, and the codebase is focused on reliable content delivery rather than complex application logic.
Simplenote for Android is a full-featured note-taking application with real-time synchronization via the Simperium protocol. It supports markdown editing, checklists, tags, collaboration via email, public note publishing, and WordPress.com posting. The app includes a passcode lock for privacy, home screen widgets, and multiple visual themes. Authentication flows cover email/password, magic link, and WordPress.com OAuth. The architecture follows MVVM with use cases, repositories, and Dagger Hilt dependency injection, mixing Java and Kotlin. The codebase is organized into three Gradle modules: the main Simplenote app, a Wear companion app, and a reusable PasscodeLock library. CI/CD is managed via Buildkite and Fastlane, with localization through GlotPress supporting 17 languages.
This repository hosts a Turkish-language Ruby 101 tutorial book, designed as a beginner's guide to the Ruby programming language. The content is authored in Markdown and organized into chapters covering Ruby syntax, data types, control structures, and practical topics like RubyGems and web development with Sinatra. The book is intended to be a portable reference for learners, emphasizing practical examples and idiomatic Ruby usage. The project is structured as a static site generated using MkDocs, with the Rakefile providing convenient commands for building, serving locally, and deploying to GitHub Pages. The mkdocs.yml configuration defines a hierarchical navigation structure, integrates the Material theme, and enables extensions for features like table of contents, syntax highlighting, and tabbed content. Dependencies are pinned in requirements.txt to ensure reproducible builds. While the documentation content reflects Ruby versions up to 3.0.2 (as of 2021), the underlying tooling remains functional and the project demonstrates maintenance through a 2026 commit history. The Rakefile represents a reusable pattern for MkDocs projects, encapsulating the common tasks of building, serving, and deploying documentation with minimal configuration. This wrapper allows developers to leverage MkDocs' capabilities without repeating command-line invocations, promoting consistency across documentation projects. The configuration file mkdocs.yml exemplifies effective use of MkDocs' features for structuring a multi-chapter book, including custom navigation and extension integration, though it is tailored to this specific book's organization.
Carbonium is a zero-runtime-dependency DOM manipulation micro-library (~1 kB) that exposes a single `$` function. In the browser, `$` resolves a CSS selector to a NodeList and wraps it in a JavaScript Proxy, so the returned value can be used both as an array of elements and as a single DOM element: property reads return the first match, property writes broadcast to every match, and DOM/array methods are proxied to support fluent chaining. HTML strings starting with `<` are parsed with DOMParser for element creation. The package ships ESM, minified ESM, and IIFE bundles built with Rollup, plus TypeScript declarations. The architecture is intentionally minimal: one source module (`src/carbonium.ts`) with a hand-written Proxy handler. The primary data flow is selector/HTML string -> `querySelectorAll`/`DOMParser` -> NodeList -> Proxy -> per-element property/method dispatch. There are no runtime dependencies; development tooling uses TypeScript, Rollup, ESLint, and Playwright. The tests inject the built IIFE into real Chromium and Firefox pages and cover chaining, filtering, classList, style methods, event listeners, and canvas access. Code inspection reveals a gap between README and behavior: direct property assignment on `.style` (e.g., `$('.indent').style.left = '40px'`) writes to `document.body.style` rather than the matched elements, because the `set` trap falls through to `Reflect.set` on the body's CSSStyleDeclaration. Method-style APIs such as `style.setProperty` and `classList.add` work as advertised because they use the captured `currentListNodelist`. The implementation also uses module-level mutable state for style/classList/relList proxies, which is acceptable for synchronous single-threaded browser code but brittle if a proxy is stored and reused across other `$` calls.
ArcadeAI is an active reinforcement-learning research codebase that trains deep RL agents to play Robotron: 2084 and Tempest inside MAME. The actual production loop works as follows: Lua scripts running inside MAME instances read game memory, flatten state into binary packets, and send them over TCP to Python servers. The Python side parses frames, computes rewards, processes states into entity/ray/grid tensors, runs DQN or PPO policies, and returns encoded joystick actions back to the emulator. Training uses Rainbow-style DQN for Tempest and a newer PPO implementation for Robotron, with expert rule bootstrapping, behavioral-cloning losses, prioritized experience replay, n-step returns, guidance-rescue mechanisms, and heavily configurable reward shaping. Both game projects include live Grafana-style web dashboards for metrics, game preview, and system monitoring. Architecturally, the repository is split into MAME-side Lua clients, socket bridges, state processors, model definitions, replay buffers, async inference batchers, and training utilities. This is a hybrid research/application repository: it is not a packaged library or service, but a set of tightly coupled research pipelines with duplicated infrastructure across the Tempest and Robotron directories. The repository also contains original Williams and Atari 6809/6502 assembly sources and ROM staging scripts; these appear to support the RL work by documenting game memory layouts, but they are not part of the active training runtime. The strongest assets are genuinely reusable: a sum-tree based prioritized replay buffer, a generic n-step return buffer, and a configurable reward-shaping module with potential-based movement shaping. These components are well-encapsulated and could be extracted into new RL projects. However, the overall codebase is a personal research dump: there are multiple abandoned engines (_old_engine), hardcoded hostnames and environment-specific paths, 3000+ line Lua/Python scripts, duplicate code across game directories, and tight coupling to MAME memory addresses. It is actively maintained and shows high engineering effort in the core training infrastructure, but reuse outside this repository would require selective extraction rather than direct adoption.
TheAlgorithms/JavaScript is an extensive open-source collection of over 700 algorithm and data structure implementations in JavaScript, designed for educational purposes. It covers a wide range of categories including sorting, searching, dynamic programming, graph algorithms, cryptography, math, string manipulation, and more. Each algorithm is implemented as a standalone module with corresponding tests, following ES module syntax. While primarily a learning resource, several components like caching classes (LRU, LFU), memoization utilities, and classic data structures (binary heap, AVL tree, Trie) demonstrate high-quality, reusable patterns. The repository employs CI/CD, linting, and automatic directory updates, ensuring code consistency. However, some modules exhibit minor issues such as DOM dependencies in Node context and duplicate implementations, reflecting the community-contributed nature of the project.
AzurLaneAutoScript (ALAS) is a Python-based game automation bot for the mobile game Azur Lane. It uses computer vision (OpenCV, template matching, OCR via cnocr/mxnet) and Android Debug Bridge (ADB) to control an emulator, automating nearly all gameplay loops: campaign sorties, daily missions, research, dormitory, guild operations, Operation Siren, and event-specific maps. The architecture is modular, with a core framework providing device abstraction (module/device), image recognition (module/ocr, module/map_detection), configuration management (module/config), and a web UI (module/webui) built on PyWebIO with an Electron wrapper. Campaign logic is organized into hundreds of per-event map scripts under campaign/, each defining map grids, enemy spawns, and battle strategies via a consistent CampaignBase subclass pattern. The system runs as a daemon, continuously executing scheduled tasks with configurable priorities and notifications (onepush, Discord). External dependencies include uiautomator2, adbutils, OpenCV, cnocr, mxnet, pywebio, and zerorpc, with pinned versions targeting Python 3.7. The codebase is actively maintained with frequent updates for new game events, but suffers from significant duplication across campaign files and reliance on outdated library versions.
This repository is not a software application, library, or framework; it is a curated reference catalog of browser-side JavaScript libraries, tools, and learning resources. The sole runtime artifact is README.md, a hand-maintained markdown list organized into dozens of categories such as package managers, bundlers, testing frameworks, UI widgets, data visualization, machine learning, and ORMs. There is no JavaScript source code, no package manifest, no import graph, and no application entry point. Classifying it as an "application" is a formality required by the binary classification schema; its real function is to serve as a community-edited index of the JavaScript ecosystem. Operationally, the repository is a contribution-driven documentation project. Changes arrive via pull requests following CONTRIBUTING.md and PULL_REQUEST_TEMPLATE.md, and a GitHub Actions workflow runs awesome_bot against README.md to detect broken links and redirects. The architecture is static markdown plus a lightweight CI validator; there are no data flows, no runtime dependencies, and no deployable components. The curated content is broad but uneven: alongside actively maintained modern tools like Vite, Zod, Playwright, and Drizzle ORM, it still lists deprecated or abandoned projects such as angular.js, Bower, SeaJS, swig, and several jQuery plugins from an earlier era. The link-checker verifies URL liveness, not relevance, so the list accumulates historical entries. The repository is valuable as a discovery index and as an exemplar of the "awesome list" format, with sensible category taxonomy, contribution conventions, and automated link validation. However, it contains no source code, algorithms, or reusable engineering components. Its maintenance cadence appears active based on recent commits and an operational CI workflow, and the curated link rot is moderate given the fast-moving JavaScript ecosystem.
This repository provides the official Helm charts for deploying Mattermost, an open-source messaging platform, and its associated services (Focalboard, RTCD, Push Proxy, Calls Offloader) onto Kubernetes. The primary deployment method is the `mattermost-operator` chart, which uses Kubernetes Custom Resource Definitions (CRDs) to declaratively manage the full lifecycle of Mattermost installations, including databases, file stores, ingresses, and scaling. Legacy charts (`mattermost-enterprise-edition`, `mattermost-team-edition`) are included but deprecated in favor of the operator. The architecture is a collection of Helm charts, with the operator chart acting as the core. It relies on external dependencies like PostgreSQL, S3-compatible storage, and optionally Elasticsearch and Grafana. The repository demonstrates strong DevOps practices, including automated CI/CD for chart releases, end-to-end testing with kind, and embedded monitoring configuration. Key reusable patterns include a Helm-embedded Grafana dashboard template for application KPIs, an ExternalSecrets integration for secure credential management, a deprecation handling template for managing breaking changes, and advanced Kubernetes storage patterns (EFS, NFS). The codebase is actively maintained but carries some technical drift from legacy components and outdated Kubernetes API versions.
GameExtractor is a desktop application designed to extract, view, and convert resources from various game archive formats. It features a plugin-based architecture that allows users to add support for new game formats without modifying the core application. The software provides a graphical interface for browsing archive contents, previewing extracted resources (images, audio, models), and performing operations like extraction, conversion, and file replacement. The application follows a modular design with clear separation between the core framework, plugin system, user interface, and utility functions. At its core, it uses a plugin architecture where format-specific handlers (archive, viewer, exporter) implement standardized interfaces. The main entry point is the GameExecutor class, launched via platform-specific scripts. Data flows from archive selection through plugin-based parsing to resource representation, then to UI display or export operations. External dependencies include numerous Java libraries for compression (zip4j, junrar, xz, lzf, lz4, zstd), image processing, audio playback, and UI components. The application supports both legacy formats and modern game engines through its extensible plugin system, with specific implementations for formats from games like Doom, Quake, Unreal Engine, Unity, and many others.
npkill is a TypeScript CLI/TUI application that scans filesystems to find node_modules (and other ecosystem build/dependency directories) consuming disk space, then interactively or programmatically deletes them. The core engine (Npkill class) exposes RxJS observable streams for scanning, size calculation, newest-file detection, deletion, and logging, with a worker_threads-based parallel directory traversal. The CLI layer adds a raw-mode interactive terminal UI with cursor navigation, multi-select deletion, search filtering, JSON/NDJSON output modes, --dry-run, .npkillrc config file support, and user-defined profiles. It ships both as a bin executable and as a programmatic Node library per API.md.
Apollo is a self-hosted game streaming server, forked from Sunshine and rebranded for compatibility with Artemis (formerly Moonlight Noir) clients. In production, it captures the host's display (via DXGI, KMS, Wayland, or NvFBC), encodes video using hardware encoders (NVENC, AMD AMF, Intel QSV, VAAPI, VideoToolbox) and audio (Opus), then streams over the network using a combination of RTSP for session control and ENet for real-time transport. It also forwards keyboard, mouse, gamepad, and pen input back to the host, enabling low-latency remote gaming or desktop control. The architecture is a single-process C++ application with a multi-threaded design: separate threads for video capture, encoding, audio capture, network I/O, and control. It exposes a web-based configuration UI (Vue.js frontend served by an embedded HTTPS server) and implements the NVIDIA GameStream HTTPS API for client pairing and session management. Platform-specific code is isolated behind abstraction interfaces (e.g., platf::display_t, platf::input_t), with dedicated implementations for Windows, Linux, and macOS. External dependencies include Boost, FFmpeg, OpenSSL, ENet, and vendor-specific SDKs (NVENC, AMF, VAAPI, etc.). The codebase demonstrates solid engineering with a clear separation of concerns, a comprehensive build system (CMake with platform macros), and a growing test suite (Google Test). However, it carries technical debt from its forked natureβsome code still references 'Sunshine' while branding leans toward 'Apollo'βand there are incomplete features on macOS (e.g., placeholder functions for clipboard) and fragile workarounds for driver bugs. Overall, it is a functional, well-maintained application with reusable patterns for inter-thread communication, resource management, and platform abstraction.
This repository provides a collection of open-source display rendering transforms (DRTs) and creative look transforms for professional color grading and compositing pipelines, specifically targeting DaVinci Resolve (via DCTL) and The Foundry Nuke (via .nk group nodes). The core functionality converts scene-referred imagery to display-referred output through a pipeline of gamut conversion, tone scale compression, hue processing, purity compression, and display encoding. It includes multiple DRT implementations (OpenDRT, Tesseract, Chromagnon, JzDT) with varying design philosophies, as well as a suite of look modification tools (ZoneGrade, NotoriousSix series, Nayatani HK, etc.) and utility transforms for gamut and log conversion. The code is grounded in color science standards (ACES, ITU-R BT.2100, CIE XYZ) and academic literature, with careful handling of edge cases through safe math functions. While the transforms are tightly coupled to their target platforms and lack automated testing, the shared header files (libDRT.h, libLMT.h) and standalone utilities demonstrate reusable patterns for color conversion and mathematical operations.
This repository contains the hardware design files, CAD models (F3D, STEP, STL), and comprehensive documentation for the ERCF v2 (Enraged Rabbit Carrot Feeder version 2), a multi-material filament changer for 3D printers, primarily the Voron ecosystem. It is not a software application in the traditional senseβthere is no executable code beyond configuration and scripting guides for Klipper firmware (Happy Hare plugin). The repo provides stl files for printing mechanical parts, CAD source files for modification, detailed assembly manuals (PDF), and step-by-step tutorials for hardware calibration, Klipper installation, and slicer setup. It also includes recommended optional add-ons (buffer, filament cutter, rewinder) and user-contributed modifications. The project is well-structured with clear directory layouts and extensive community support, evidenced by high stars and active issue tracking.
This repository is the official awesome list for OpenCode, a terminal AI coding agent. It maintains a curated catalog of plugins, themes, agents, projects, and resources as YAML files under data/. A small set of Node.js scripts validates the YAML against a JSON schema, generates the README.md from a template, and exports a normalized dist/registry.json for downstream consumers such as opencode.cafe. CI workflows validate PRs and automatically regenerate the README/registry whenever the YAML data changes. Architecturally this is a data-driven build tool: YAML files are the source of truth, and scripts/validate.js, scripts/generate-readme.js, and scripts/export-json.js are the functional entry points. They use standard dependencies (ajv, js-yaml, glob) and are organized cleanly. There is no runtime service, API, or library here; the repo is a curated content registry plus lightweight tooling to keep the catalog consistent and machine-readable. The code is straightforward, with no tests but with solid validation and a well-designed schema.
This repository implements an agentic crypto trading platform called AI Market Maker (AIMM). Despite the name, the code is not a low-latency market-making engine; it is a multi-agent hedge-fund-style trading stack that combines LLM-driven research agents with deterministic quant logic for backtesting, paper trading, and live trading. The core execution path is a LangGraph workflow: nine Tier-0 specialist agents (monetary, news, TA, on-chain, order flow, etc.) produce structured signals, a weighted arbitrator fuses them into trade intents, a Risk Guard vetoes dangerous proposals, and portfolio management routes execution through an OMS with an in-memory or SQLite ledger. The platform includes a FastAPI backend with REST and streaming endpoints, a Next.js/React dashboard, Docker deployment, Alembic migrations, CI, and a large test suite.