This is a JavaFX desktop application for playing, analyzing, and linking Chinese chess (Xiangqi). It supports UCI and UCCI chess engines, allowing human vs. engine or engine vs. engine play, as well as pure analysis. The application includes opening book management (local SQLite-based books and a cloud book via chessdb.cn), game record handling (PGN, TXQ, XQF, CBR formats), and a unique "linking" feature that automates play on external chess platforms using screen capture (YOLO models) and mouse simulation. The architecture follows a standard JavaFX MVC pattern with FXML views and controller classes, but the main Controller is monolithic (~900 lines). Cross-platform support is achieved through platform-specific linker implementations (Windows JNA, Linux X11, macOS osascript). The codebase demonstrates solid engineering with reusable utility classes and callback interfaces, though some dependencies are hardcoded and platform linkers are fragile.
FunPayVertex is a Telegram-controlled automation bot for the FunPay digital marketplace, written in Python. It scrapes FunPay's internal API to provide auto-delivery of digital goods, auto-reply to chat messages, auto-raise of listings, and inventory management (auto-restore/disable lots). The architecture is event-driven: the `FunPayAPI.Runner` polls FunPay's `/runner/` endpoint and emits typed events (new orders, messages, reviews) which are dispatched to registered handlers in `handlers.py` and through a plugin system. The Telegram bot (`tg_bot/`) serves as the primary user interface, offering menus for configuration, notifications, plugin management, and proxy settings. The codebase is modular with a separate `FunPayAPI` package that could be reused independently. It lacks tests and CI/CD, and relies on scraping HTML/CSS selectors that may break with site updates, contributing to a medium technical drift rating. The plugin system and localization framework are well-designed and potentially reusable.
This repository is a retired reference implementation for deploying AI coding agents (CLAWDINATORs) on AWS using NixOS. It provides a complete image-based provisioning pipeline: NixOS images are built with nixos-generators, uploaded to S3, imported as AMIs, and launched as EC2 instances via OpenTofu. The agents run the openclaw gateway, connecting to Discord and GitHub to monitor repositories and assist maintainers. The system includes shared memory via EFS, a control plane Lambda for fleet management, GitHub App token refresh, and scheduled GitHub state sync. The codebase is well-structured with a modular NixOS module, clean shell scripts, and proper infrastructure-as-code patterns. However, the project is explicitly retired (fleet decommissioned August 2026, workflows disabled), so it serves primarily as a historical reference and learning resource for NixOS-on-AWS deployment patterns.
This repository serves as the customer test registry for the Flutter framework. It contains .test configuration files in the `registry/` directory that define how to fetch, update, and run tests from external Flutter packages (e.g., flame, provider, devtools) in CI. These tests are executed with every Flutter commit to detect regressions. The repository also includes a separate `skp_generator` Flutter application that generates SKP files of Flutter scenes for Skia's use in regression and performance testing. The codebase is implemented primarily as shell scripts (bash/batch), GitHub Actions workflows, and a small Dart program. It is not a reusable library but rather an operational glue repository for integrating third-party Flutter tests into the Flutter CI pipeline. The architecture is simple: test definitions (key-value format) are parsed by a Dart runner (`dev/customer_testing/run_tests.dart` in the Flutter repo) which fetches, updates, and runs the tests as per the directives. The SKP generator is a separate utility with its own build script and Dart code for scene rendering.
ClawCloud-Run is a GitHub Actions-based automation script designed to automatically log into ClawCloudRun cloud service to maintain account activity. The system handles GitHub OAuth authentication, device verification, and two-factor authentication (via GitHub Mobile or Telegram-delivered TOTP codes). After login, it navigates to the console and apps pages to keep the session active, extracts the updated session cookie, and either updates it in GitHub Secrets or sends it via Telegram for manual update. The architecture consists of a workflow triggering a Python script that uses Playwright for browser automation, requests for API interactions, and pynacl for secret encryption. Key entry points are the GitHub Actions workflow (scheduled every 5 days) and the Python script's main execution loop.
nuxt-purgecss is a Nuxt 3 module that integrates PurgeCSS to remove unused CSS from the final build. It hooks into Nuxt's PostCSS configuration to add the `@fullhuman/postcss-purgecss` plugin with sensible defaults tailored for Vue and Nuxt projects. The module automatically scans common Nuxt directories (components, layouts, pages, composables, app files, plugins, and nuxt.config) for used CSS classes, and includes a safelist of typical Nuxt classes (e.g., transition classes, nuxt-link classes, scoped style attributes) to prevent accidental removal. It also provides a custom default extractor that strips inline `<style>` blocks from Vue Single File Components before extraction, ensuring that only classes used in templates are considered. The module is disabled by default in development mode and can be configured via the `purgecss` key in `nuxt.config`. The codebase is small, well-structured, and includes integration tests using `@nuxt/test-utils` that verify correct purging behavior on a playground Nuxt project. However, the project has seen no releases since September 2022 and relies on outdated dependencies (e.g., Nuxt 3 RC, Node 16 in CI), indicating it is no longer actively maintained.
This is a PHP library that provides a RESTful server implementation for the CodeIgniter 3 framework. It extends the base CI_Controller with automatic HTTP method routing, input parsing (GET, POST, PUT, DELETE, etc.), and output formatting (JSON, XML, CSV, HTML, etc.). The library includes built-in support for API key authentication, basic/digest auth, LDAP, rate limiting, request logging, and CORS. The core is RestController, which uses a _remap method to route requests to controller methods named like `users_get()`. The Format class handles data serialization/deserialization and is a well-crafted, standalone component. The architecture is a typical CodeIgniter library with a configuration file and optional authentication helpers. It is tightly coupled to CodeIgniter 3, meaning it is not reusable outside that framework, but it serves its purpose effectively for building REST APIs on CI3.
This repository is a curated list (an 'awesome list') of resources for learning and practicing algorithms. It is not a software application, library, or data pipeline. The entire content is a single README.md file that organizes links to books, online courses, competition websites, and cheat sheets into categories. There are no executable scripts, tests, or configurations. The value of the repository lies entirely in its curated content, not in any software craftsmanship or architecture.
This repository is a large, curated collection of vulnerability proof-of-concepts (PoCs), exploit scripts, detection rules (Snort), and detailed documentation for 1-day/N-day vulnerabilities, primarily targeting Chinese enterprise software (e.g., UFIDA NC, Weaver OA, Landray OA, D-Link NAS, WordPress plugins). It serves as a reference for red-team operations, penetration testing, and security research. The repository is not a single application but a set of standalone tools; key entry points include Python exploit scripts (e.g., CVE-2024-27198.py, qvd-2024-11354.py), JWT forgery utilities, and Nuclei YAML templates. Content spans 2024-2026, with consistent reporting templates covering vulnerability status, risk assessment, FOFA search syntax, reproduction steps, and remediation advice. The code quality is uneven—many scripts are minimal, single-purpose PoCs, but some components like the D-Link interactive shell scanner and JWT forgery scripts demonstrate moderate reusability. Overall, it is a valuable knowledge base for security testing, though not a polished software product.
Caesar.jl is a comprehensive Julia library for non-Gaussian, multimodal factor graph inference primarily targeting SLAM (Simultaneous Localization and Mapping) and robot perception. It implements the mm-iSAMv2 algorithm, supporting both parametric and non-parametric belief representations (KDE), incremental smoothing and mapping, multi-hypothesis data association, and on-manifold inference. The library provides a rich set of variable and factor types (e.g., Pose2, Point2, BearingRange, Pose2Pose2) and integrates with various sensor modalities via weak extensions: AprilTags, image features, point clouds (PCL), beamforming (synthetic aperture sonar), and ZMQ-based multi-language services. The architecture is a monolithic Julia package with a clear public API (ExportAPI.jl) and a factor graph construction pattern (initfg, addVariable!, addFactor!, solveTree!). It relies heavily on the external IncrementalInference.jl, RoME.jl, and DistributedFactorGraphs.jl packages. While the core framework is production-caliber, the repository includes a large number of experimental and research examples (marine, wheeled, aerial) that are often unmaintained, resulting in moderate technical drift. The library is actively maintained (CI, CompatHelper, TagBot) but contains deprecated APIs and Julia version sensitivity.
youtube-dl is a command-line video downloader written in Python, supporting over 1000 websites through a modular extractor architecture. The system is built around a core InfoExtractor base class (common.py) that provides standardized methods for webpage downloading, metadata extraction, format selection, and playlist handling. Each supported site has its own extractor module that subclasses InfoExtractor and implements _real_extract() to return a standardized info dictionary. The architecture uses a lazy-loading mechanism (lazy_extractors.py, generated by make_lazy_extractors.py) to avoid importing all extractors at startup. Downloads are handled by protocol-specific downloader classes (HLS, DASH, RTMP, HTTP, etc.) selected based on the stream protocol. Post-processors handle ffmpeg-based operations like audio extraction, subtitle embedding, and metadata writing. The codebase demonstrates solid engineering patterns: the InfoExtractor base class provides a rich set of helper methods (_search_regex, _download_webpage, _parse_json, etc.), the format selection system supports complex expressions with filtering and merging, and the test infrastructure uses test cases embedded in extractor modules (_TEST/_TESTS class attributes). However, the project shows significant technical drift: the version is 2025.04.07 but the test data references 2013 versions, Python 2.6/2.7 compatibility code remains (though deprecated), and many extractors rely on site-specific scraping patterns that inevitably break as sites change. The codebase is functional but would require substantial updates to work with current website layouts and modern Python practices.
Kurrier is a self-hosted, multi-tenant communications workspace that combines email, calendar, contacts, and file storage into one product. It runs as a pnpm monorepo with three deployable apps: a Next.js App Router frontend (apps/web) using server actions and locale-prefixed dashboard routes for mail, calendar, contacts, drive, and platform settings; a Nitro-based worker (apps/worker) that exposes REST management APIs under /api/kurrier, inbound email webhooks for SES/Mailgun/Sendgrid/Postmark/Mailtrap, and CalDAV/CardDAV/WebDAV endpoints while consuming BullMQ/Redis background jobs for IMAP, Gmail, JMAP, and DAV sync, rule processing, search indexing, and scheduled sends; and a Fumadocs documentation site (apps/docs). Persistence is PostgreSQL via Drizzle ORM with row-level security keyed to JWT workspace claims, raw email and attachments live in S3-compatible object storage, and Typesense powers mailbox and thread search.
Honkers Launcher is a Linux desktop application written in Rust with GTK4/libadwaita and Relm4 that installs, updates, repairs, and launches an unofficial Honkai Impact game through Wine. The code implements a complete first-run wizard, Wine prefix management, DXVK/voiceover component downloads, Sophon-based diff update and predownload logic, telemetry disabling, and a preferences system covering gamescope, bubblewrap sandboxing, FSR, environment variables, and other game-session enhancements. It is one member of the an-anime-team launcher family and delegates low-level game API, configuration schema, and update mechanics to the external `anime-launcher-sdk` crate. The application is structured as a Relm4 component tree: a main window state machine, a preferences window, a first-run carousel, and reusable UI components for component lists and progress bars. Localization uses Fluent across 20 languages, and `assets/resources.xml` is compiled into a GResource bundle by `build.rs`. Entry points are in `src/main.rs`, with CLI flags supporting direct game launch and session selection. Data flows center on configuration via `Config::get/update`, a synchronized components index from GitHub, and download/install operations routed through the SDK. Maintenance is explicitly in maintenance mode: the README describes the project as feature complete and focused on bugfixes and support for new game versions. The codebase shows some drift—`rustfmt.toml` targets edition 2024 while `Cargo.toml` uses 2021, the CI runs only `cargo check` rather than tests or clippy, stale localization strings remain after removed features, and there are several `unwrap` calls and global `unsafe` window singletons—but the modular structure and reusable widgets make it a reasonable reference for GTK4/Relm4 launcher development.
Notty is a full-stack, cross-platform notes application (an Apple Notes-style clone) built with a React 19 + Vite + Tailwind 4 frontend, a Hono API running on Cloudflare Workers, and per-user Durable Objects that each own a SQLite database. Clients include a web app, a Tauri 2 desktop app (with local SQLite, markdown export/import, cloud sync, deep-link auth, and a quick-note hot corner), and a mobile variant. Realtime collaboration is powered by Yjs with three persistence paths (Durable Object SQLite, browser IndexedDB, and Cloudflare R2), and authentication uses Better Auth with passkeys, Google/GitHub/Apple social login, and anonymous sessions. The backend also serves server-rendered public pages generated from TipTap JSON with URL sanitization and RSS 2.0 feeds, and integrates Supermemory for AI-powered note indexing. File storage and full version-history snapshots live in R2, with branch management (create/checkout/merge/delete), diff views, and restore-with-auto-backup. The architecture is notable for its platform adapter pattern (web/desktop/mobile adapters abstracting storage and sync) and per-user Durable Object isolation, but the codebase carries meaningful baggage: dead code from an earlier NextAuth-based iteration (src/lib/auth.ts, old NotesContext, DarkModeSwitch, search-results.tsx), no visible unit tests beyond a race-condition QA script, a non-standard FNV-1a-based lock token instead of a real HMAC, and a merge operation that is actually a replace. Optimistic update logic in the notes context is fragile and can diverge from server state under rapid tab switches. Despite these issues, the core architecture is sound and the adapter pattern is genuinely reusable.
This repository contains the Virtuoso Open-Source multi-model database server, primarily written in C, with extensive client libraries in Java, C#, and PHP. In production, it functions as a relational database, RDF triple store, SPARQL query endpoint, XML processor, and application server (VSPX). The architecture is a monolithic server process with plugin extensions for hosting languages (CLR, Java, PHP) and connectivity via ODBC, JDBC, OLE DB, and ADO.NET. Key entry points include the Virtuoso server binary (built from libsrc/Wi/ and libsrc/Dk/), ODBC driver (binsrc/virtodbc/), JDBC Type 4 driver (libsrc/JDBCDriverType4/), and .NET client (binsrc/VirtuosoClient.Net/). Data flows include SQL parsing and execution via the Wi module, RDF/SPARQL query processing, and WebDAV/HTTP file management through the built-in web server. External dependencies include PCRE, zlib, HTML Tidy (libsrc/Tidy/), and curl. The repository also contains a suite of web applications (ODS) for blogging, bookmarks, calendar, wiki, etc., built on a common SQL-based framework, and a comprehensive test suite covering performance benchmarks (BSBM, LUBM, TPC-D/H). Despite its breadth, the codebase shows signs of age: multiple duplicate Jena driver versions, a legacy Ajax toolkit (OAT), and hardcoded paths in test scripts. It remains actively maintained with regular commits and issue triage.
The Kross Hugo theme is a static site generator template designed for creating personal portfolio websites. It provides a complete set of HTML templates, SCSS stylesheets, and JavaScript functionality that transforms Markdown content into responsive, interactive websites using the Hugo static site generator. The theme follows Hugo's conventional directory structure with layouts for templating, assets for styling and scripts, and archetypes for content templates. It integrates modern web technologies including Bootstrap 5 (via Hugo module), Swiper for touch-enabled sliders, Shuffle for filtering and masonry layouts, and custom JavaScript for UI enhancements like sticky navigation, parallax effects, and attribute-driven styling. The theme emphasizes performance with built-in optimization for Google Page Speed scores. While much of the code is theme-specific, the implementation contains several reusable patterns that demonstrate thoughtful frontend development. Notably, the mouseParallax function in assets/js/script.js provides a self-contained implementation of mouse-followed parallax effects that could be extracted and reused in other projects with minimal modification. The theme also showcases good practices in SCSS architecture with modular styling, responsive typography scaling, and reusable mixin patterns. The project shows evidence of ongoing maintenance with compatibility for recent Hugo versions and configuration for modern deployment platforms like Netlify and Vercel. It addresses common requirements for personal websites including contact forms, social media integration, client showcases, and testimonial sliders, making it a practical solution for developers seeking to quickly deploy professional portfolio sites.
This repository provides Arduino-based examples and setup instructions for the LilyGO T-Display S3 board (ESP32-S3 with ST7789 TFT display). It demonstrates core functionalities including TFT graphics rendering, button input handling, backlight control, and ESP-NOW wireless communication. The architecture consists of standalone Arduino sketches (.ino files) that share common configuration headers and resource files. Each example is self-contained and targets specific use cases: image display with progress bar (HotHead), backlight dimming (HotHead_DimmerNEW), simplified graphics (HotHead_2025), bidirectional button state sharing via ESP-NOW, and a basic serial test. The repository emphasizes hardware-specific configuration through header files that define display initialization, board settings, and embedded image resources.
KEA Research is a full-stack multi-provider AI research chat application. The backend is a FastAPI service backed by SQLite/SQLAlchemy, exposing chat, admin, health, user, and TTS endpoints. The frontend is an Astro + TypeScript single-page app that stores chat history and pipeline data in IndexedDB, with a Bootstrap-based UI. Deployment is containerized via Docker Compose with nginx handling TLS and SSE-friendly proxying. The core product logic is a four-step research pipeline: initial multi-provider responses, Mixture-of-Agents refinement, peer evaluation, and a final KEA synthesis with facts, consensus, flagged claims, rankings, and confidence scores. A web admin panel manages providers, models, provider sets, users, and app settings, while the frontend supports research layers, bookmarks, notes, drafts, export, attachment ingestion, and text-to-speech via a Kokoro ONNX model.
This repository is a research prototype for efficient LLM inference, specifically optimizing attention memory management via the vAttention technique (ASPLOS 2025). It contains three primary components: (1) a modified NVIDIA GPU kernel driver (nvidia-vattn-uvm-driver) that enables sub-2MB page sizes for Unified Virtual Memory (UVM), (2) a fork of the Sarathi-Serve LLM serving framework (sarathi-lean) integrated with vAttention, and (3) custom attention kernel implementations (pod_attn, vattention) using CUTLASS and FlashAttention backends. The system supports multiple attention backends (FlashAttention, FlashInfer, paged, variable-length) and includes extensive benchmarking and plotting scripts for reproducibility of research results. Architecturally, the user-space inference stack uses a scheduler (Orca or Sarathi), a cache engine (vLLM-style or vAttention), and model executors with tensor/pipeline parallelism. The vAttention cache engine replaces traditional paging with CUDA virtual memory allocation, decoupling virtual and physical memory for KV-cache. The custom NVIDIA UVM driver patch is required to support fine-grained page sizes. The repository also includes microbenchmarks for attention kernel performance and page size effects, as well as artifact scripts to reproduce figures from the associated paper. While the codebase demonstrates solid engineering for a research project (clean abstractions, registry pattern, modular design), it is explicitly not production-ready. Key limitations include strict version dependencies (PyTorch 2.3.0, CUDA 12.1), reliance on a modified kernel driver, and incomplete feature parity with production systems like vLLM. The inclusion of a fully vendored CUTLASS library and auto-generated NVIDIA driver headers adds significant size but provides reusable GPU primitives. The research scripts are functional but contain hardcoded paths and are tightly coupled to the experimental setup.
Upstat is a self-hosted, open-source status monitoring and uptime tracking tool. The system consists of a Go (Fiber v2) backend API and a Next.js 15 web dashboard, deployed via Docker Compose with support for both PostgreSQL and SQLite databases. The backend periodically pings configurable HTTP endpoints, records heartbeats, calculates uptime percentages, and manages incidents triggered by status transitions. It integrates with multiple notification channels (Discord, Slack, Telegram, Ntfy, Gotify) and provides public status pages with real-time latency charts. The frontend uses shadcn/ui components, React Hook Form with Zod validation, and a custom client fetch wrapper for authenticated API calls. The monorepo also includes a documentation site (Fumadocs) and a static landing page. While the architecture is well-structured with clear separation of concerns (controllers, routes, models, utils), the codebase shows signs of technical drift including outdated dependencies, hardcoded secrets in Docker Compose files, committed SQLite database artifacts, and documentation inconsistencies between the manual API docs and generated OpenAPI spec. The project is functional and suitable for small to medium deployments but would benefit from dependency updates and cleanup before production use.