Plyr is a client-side JavaScript library providing a customizable, accessible media player for HTML5 video/audio, YouTube, and Vimeo. It encapsulates a complete UI (controls, captions, fullscreen, progress, volume, menus) with a modular architecture—core player class, provider-specific adapters, plugins (ads, preview thumbnails), and a comprehensive utility layer for DOM manipulation, events, storage, and browser detection. The player is configured via a nested defaults object and CSS custom properties, enabling deep theming without CSS overrides. Despite its polished implementation, Plyr is officially deprecated in favor of Video.js 10; the project will only receive security patches until January 2028. The demo site at plyr.io now showcases Video.js, not Plyr. The codebase remains a solid example of media player architecture and is safe to use in legacy projects, but new integrations should adopt Video.js. Reuse value lies in its well-isolated modules: the event system, storage abstraction, fullscreen wrapper, and plugin pattern can be extracted with minimal modification.
Samarium is a modular, all-in-one business management system (ERP/CMS) built with Laravel 11 and Livewire 3. It provides a comprehensive admin dashboard for small to medium businesses, covering sales invoicing, purchase orders, expense tracking, inventory management, accounting (double-entry ledger, trial balance, income statement), customer/vendor relationship management, and a full content management system (webpages, posts, galleries, navigation menus, themes). It also includes e-commerce capabilities (product catalog, shopping cart, online orders), appointment booking, team management, calendar with Nepali date support, and additional modules like vacancies, testimonials, newsletters, and document/URL link management. The system is configurable via a module toggle in config/app.php and supports both a dashboard interface and a public-facing website. The architecture follows a standard Laravel MVC pattern with Livewire components handling all interactive UI. Each business domain has its own set of Livewire components (e.g., SaleInvoiceEditor, ProductDisplay) that use a shared ModesTrait for state management. A service layer provides pagination and CRUD logic, though many service methods are incomplete. The frontend uses Bootstrap 4, Font Awesome, and Chart.js for reporting. The system is Dockerized for easy deployment and includes seeders for demo data. While the codebase is functional and covers a wide feature set, it exhibits several quality issues: mixed namespaces (some models under App\, others under App\Models\), hardcoded values (VAT 13%, Nepali month arrays), incomplete features (many TODO comments, empty service methods), and code duplication (multiple similar Livewire components for editing fields). The Nepali calendar support is a distinctive feature but requires manual maintenance of hardcoded date ranges. Overall, Samarium is a solid, feature-rich ERP for its target audience but would benefit from refactoring and stricter coding standards.
This repository implements Pixie, a research framework for predicting dense physical material fields (density, Young's modulus, Poisson's ratio, material ID) from 2D image observations of 3D objects. Hydra configs drive a multi-stage pipeline: Objaverse object retrieval, Blender rendering, NeRF-based CLIP feature field training (F3RM), Gaussian Splatting training, voxel grid feature extraction, VLM-based or neural material segmentation, and MPM physics simulation via the vendored PhysGaussian codebase. The pipeline.py entry point orchestrates these stages with caching and reproducibility checks, while render.py produces Blender visualizations of segmented physics fields. Real-scene mode extends the same pipeline to captured datasets using COLMAP dataparsers. The repository also contains the full PixieVerse data curation workflow: class-based Objaverse selection using sentence-transformers, large-scale parallel Blender rendering, VLM-based filtering and critique (Gemini/Claude/GPT/Qwen via the vendored vlmx agent framework), and Streamlit tools for human-in-the-loop label correction and simulation validation. The discrete (semantic segmentation) and continuous (property regression) 3D UNet training lives in the vendored Wavelet-Generation submodule, with shared utilities in pixie/training_utils.py and normalization statistics already computed in normalization_stats/. Architecturally this is a hybrid research/application repository: primarily a configuration-driven pipeline framework with CLI entry points, but also a dataset-generation and model-training workflow. It depends heavily on vendored third-party code (nerfstudio, f3rm, PhysGaussian, Wavelet-Generation, vlmx) and shells out to Blender, CUDA rasterizers, and Hugging Face. Quality is research-grade: disciplined Hydra configs, contextual config snapshots, and skip-if-exists caching coexist with hardcoded user-specific paths, commented-out dead code, and a subprocess-heavy orchestration style. Download scripts for pre-trained models and the PixieVerse dataset are included and functional.
FinRL-Meta is a comprehensive Python library and framework for applying deep reinforcement learning (DRL) to financial trading. It provides a modular, plug-and-play ecosystem consisting of market environments (stock, crypto, futures, forex, portfolio allocation, order execution optimization, market impact), data processors (Yahoo Finance, Alpaca, Binance, Tushare, etc.), and DRL agent wrappers (Stable-Baselines3, ElegantRL, RLlib). The library implements the full training-testing-trading pipeline, with CLI entry points (train.py, test.py, trade.py), backtesting engines (WonderTrader integration for futures), and paper trading capabilities (Alpaca). It is the market environment layer of the larger FinRL ecosystem and includes research-grade features such as market impact models, turbulence index, and ensemble strategies. The codebase is hybrid: while primarily an application/library, it contains numerous Jupyter notebooks, experimental sub-projects (order execution with qlib, high-frequency futures), and academic paper references. This reflects its dual role as both a reusable software framework and a research reproducibility platform. The architecture is well-structured with abstract base classes (data processors, impact models, environments), factory patterns, and consistent Gym/Gymnasium interfaces. However, the repository also carries technical debt from its research origins: hardcoded paths, mixed gym versions, deprecated library usage, and some incomplete or commented-out code. The most reusable components are the data processor base class (providing a common data pipeline) and the pluggable impact model hierarchy, both of which can be extracted with minimal modification for other financial RL or simulation projects.
This repository is a large collection of bare-metal firmware projects for STM32 microcontrollers (F0, F1, F3, G0, G4 families), authored by Edward V. Emelianov. It contains dozens of independent example and application projects covering USB CDC virtual serial ports, CAN bus gateways, sensor drivers (BMP280, MLX90640, DHT22, DS18B20, etc.), stepper motor control, servo control, LED displays, and more. The code is written in C with direct register access (no HAL) and uses a custom USB stack with ring-buffer-based I/O. Each project is self-contained with its own main.c, hardware initialization, and command parser, typically communicating over USB or UART with a simple text-based protocol. The architecture is monolithic per project: a main loop processes periodic tasks (ADC sampling, sensor reads, CAN message handling) and responds to commands received via USB or UART. Key entry points are the main.c files in each project directory. Data flows involve sensor acquisition (ADC, I2C, SPI), optional processing (median filtering, dew point calculation), and output via USB CDC, CAN, or UART. External dependencies are minimal: only an ARM GCC toolchain and the STM32 CMSIS-like headers provided in the inc/ folder. The repository also includes KiCad PCB designs and gerber files for many projects, indicating a full hardware+software development cycle. While the code is functional and covers a wide range of embedded use cases, it suffers from significant code duplication (ringbuffer.c, usb.c, strfunc.c are copy-pasted across many projects) and lacks a centralized library or build system. Deprecated folders and multiple versions of similar projects (e.g., chronometer_v2, chronometer_v3) add clutter. The repository is best viewed as a personal collection of working examples and prototypes rather than a polished framework. However, several components (ring buffer, string utilities, USB stack) are well-implemented and could be extracted for reuse in other STM32 projects.
This repository is a Node.js/TypeScript library for dependency injection (DI), heavily inspired by Symfony's DI container. It provides a service container that manages object construction, autowiring (automatic dependency resolution from constructor parameter types), and service configuration via YAML, JSON, JavaScript, and XML files. The library supports advanced features such as compiler passes, service decoration, tagged and keyed services, conditional service registration, lazy loading, and graph export. It includes a CLI tool for generating configurations and inspecting the container. The architecture follows a modular design: a ContainerBuilder manages definitions and compilation, loaders parse configuration files, and a compiler runs passes in ordered phases (optimization, removal, decoration). Autowiring uses TypeScript's AST (via @typescript-eslint/typescript-estree) to scan source files and register services automatically. The library also provides validation, graph export in multiple formats (JSON, Mermaid, DOT), and a condition evaluation system for environment-aware service registration. The codebase is well-structured with clear separation of concerns, extensive tests (both JavaScript and TypeScript), and demonstrates several design patterns (compiler pass, strategy for loaders/dumpers, reference objects, condition evaluation). However, the project appears unmaintained: the last CHANGELOG entry is from 2018, dependencies are outdated (e.g., commander v8, chalk v4, TypeScript 4.6.4), and the package.json version is 0.0.0. Despite its age, the core concepts remain relevant and the code quality is solid for a library of its kind.
This repository contains firmware for a programmable e-ink badge using the Pimoroni Badger2040 hardware. It provides multiple applications (badge display, QR code viewer, fortune quote viewer) that can be launched via physical buttons, with a launcher managing state persistence between runs. The system is built in MicroPython and saves application state to JSON files in a /state directory. While designed as a fun project to showcase personality and retro technology affection, it demonstrates solid embedded systems practices with modular app design and persistent state management.
Fwitter is a Twitter-like social media application built with React and FaunaDB. It functions as a single-page application where the frontend communicates directly with FaunaDB for all data operations, authentication, and authorization. The architecture uses React hooks for state management, React Router for navigation, and FaunaDB's User Defined Functions (UDFs) encapsulated in a query manager layer to handle data interactions securely. Key features include user registration/login, posting text/media content, liking/commenting/refweeting, following users, and searching by tags or usernames. The application demonstrates FaunaDB's capabilities for building serverless applications with fine-grained access control through roles and UDFs.
TCPDF is a PHP library for programmatic PDF generation, originally a monolithic single-file engine. The current version (7.0.7) is a compatibility facade that delegates all rendering to the modern `tecnickcom/tc-lib-pdf` engine, preserving the legacy 291-method public API while the internal engine is replaced. The library is explicitly deprecated and in maintenance-only mode; users are encouraged to migrate to `tc-lib-pdf` directly. It provides a comprehensive set of features for creating PDF documents: text and HTML rendering, images, barcodes (1D and 2D), forms, digital signatures, encryption, PDF/A compliance, and more. The codebase includes a rich test suite (PHPUnit) with a reusable base test class, a smoke test runner for all 68 example scripts, and a method-mapping tool that generates the authoritative documentation of delegation status. The deposit is a library, not a standalone application, and is intended to be integrated into PHP applications via Composer.
This repository provides a bash script (`mnf`) and an nftables rules file (`mullvad.rules`) that enable running Mullvad VPN alongside Tailscale or Zerotier on Linux. The script orchestrates the Mullvad CLI, nftables, and the mesh networking service to ensure traffic from the Tailscale/Zerotier network bypasses the VPN (or is correctly routed) while all other traffic goes through Mullvad. It supports country selection, RAM-only servers, custom DNS, and selective teardown. The code is a single, well-structured bash script with clear functions and argument parsing. It is not a library or framework but a purpose-built tool for a specific network configuration problem. The repository has a small footprint, no tests, and no CI/CD, but it is actively maintained (last commit dated 2026-05-07, though this appears anomalous). The nftables rules file is a simple configuration that marks packets from excluded IP ranges. There are no reusable software components beyond the script itself, which is tightly coupled to the Mullvad/Tailscale/Zerotier ecosystem.
FUXA is a full-stack web-based SCADA/HMI platform for industrial automation. It provides real-time data acquisition from a wide variety of PLCs and industrial protocols (Modbus, OPC UA, Siemens S7, BACnet, MQTT, etc.), a drag-and-drop SVG editor for building process visualization dashboards, and runtime rendering with alarms, data logging (DAQ), scripting, recipes, and scheduling. The architecture is a monolithic Angular 18 frontend with a Node.js/Express backend, communicating via Socket.IO and REST APIs. It also supports Electron desktop packaging and Node-RED integration. The codebase is large and functional, with many device drivers and UI controls, but suffers from code duplication, copy-paste driver implementations, mixed coding styles, outdated dependencies (moment.js, CoffeeScript gauge library), and a large un-lazy-loaded Angular module. Despite these issues, it is actively maintained and used in production by many industrial users.
This repository implements a full-featured graphic design SaaS application, a clone of Canva. It is built with Next.js 14 (App Router), React 18, TypeScript, Tailwind CSS, and uses Fabric.js 5.3.0 for the canvas editor. The application allows users to create visual projects (designs) with layers including shapes, text, images, drawings, and AI-generated content. It supports background removal, image filters, color manipulation, and font adjustments. Authentication is handled via NextAuth v5 with credentials, GitHub, and Google OAuth, integrated with a PostgreSQL database through Drizzle ORM. Subscriptions (Free/Pro tiers) are managed via Stripe, limiting certain features like unlimited projects and AI capabilities. The dashboard lists user projects and templates, while the editor provides a rich toolbar, collapsible sidebars, and keyboard shortcuts. External dependencies include Unsplash for stock images, UploadThing for user file uploads, Replicate for AI inference (image generation, background removal), and Stripe for payments. The architecture follows a feature-based module structure with dedicated folders for auth, editor, projects, subscriptions, AI, and images. Server API routes are built using Hono.js mounted under a catch-all route, and client-side data fetching uses TanStack Query. State management for modals and UI is handled by Zustand. The codebase is well-organized for a production-grade tutorial project but lacks automated tests and contains some type safety shortcuts.
This repository is a personal Emacs configuration and extension collection ('lazycat-emacs') by Andy Stewart, not a standalone application or service. It is organized as a modular Emacs Lisp setup: site-start.el bootstraps the load path, site-lisp/config/init.el loads per-feature init-*.el files covering languages, UI, AI assistants, LSP, IRC, email, and window management. The bulk of the code lives in site-lisp/extensions/lazycat/, a large grab-bag of self-contained Emacs Lisp utilities and minor modes, plus vendored third-party packages (SLIME, magit-section, doxymacs, ghc-mod, ruby-tools) and a comprehensive yasnippet snippet collection. It also bundles StarDict dictionary files and tree-sitter grammar binaries for offline lookup and modern syntax highlighting.
ipdb is a thin wrapper that provides IPython's enhanced debugger (tab completion, syntax highlighting, better tracebacks) as a drop-in replacement for the standard pdb module. It exposes a functional API (set_trace, post_mortem, run, runcall, etc.) and a command-line interface for debugging Python scripts. The codebase is minimal and relies entirely on IPython for core debugger functionality. It supports configuration via multiple file formats (setup.cfg, .ipdb, pyproject.toml) with prioritized loading, as well as environment variables. The project has good test coverage for configuration parsing and CLI options, but the overall logic is thin and tightly coupled to IPython internals.
This repository is a collection of configuration files (Quantumult X rewrite rules) for ad blocking and UI customization across dozens of Chinese mobile apps and websites. The rules intercept network requests, reject advertising endpoints, modify API responses using JSON-jq expressions, or redirect traffic to remove promotional content. Key modules cover apps like Weibo, Amap, Bilibili, Netease Music, and Douban, as well as function scripts for YouTube ad removal, Bilibili subtitle conversion, and Emby media server enhancements. The architecture is flat: each .conf file is a standalone rule module that can be imported into Quantumult X. The repo is not a software application itself but a set of well-documented, actively maintained proxy configurations. There is no application code, data pipeline, or reusable library; the value lies in the precise, battle-tested URL patterns that demonstrate deep reverse-engineering of app APIs. The repo is highly specialized for Chinese app ecosystems and requires Quantumult X (or compatible proxy tools) to function.
This repository is the official Library of Congress distribution point for the api.congress.gov API. It contains documentation, an OpenAPI specification, and example client libraries in Python and Java. The code is not a production service itself, but rather the SDK and documentation for one. The architecture is a simple monorepo. The Python client (cdg_client.py) demonstrates a clean dynamic delegation pattern for navigating hierarchical REST APIs. The Java client (CDGClient.java) mirrors this using standard library HTTP. A significant organizational flaw is the duplication of client code across python/ and api_client/python/ (and similarly for Java), which introduces version drift and config inconsistencies (e.g., x_api_key vs api_key). The OpenAPI specification is comprehensive but contains several typos (bioguidId, lastestAction, geAmendmentTexts), indicating a lack of automated validation in the documentation pipeline. Despite this, the spec is a valuable reference for the structure of U.S. legislative data. Maintenance is active (commits dated into 2026), but the organizational drift suggests the project is growing without strict refactoring discipline. The most reusable assets are the client library patterns, which can be extracted for any similar hierarchical API.
This repository is a Node.js library implementing an OpenID 1.0/1.1/2.0 Relying Party (client). It enables Node.js applications to authenticate users via OpenID providers by handling discovery, association, authentication, and assertion verification. The library is modular, with separate modules for HTTP requests, XRDS parsing, and extension handling (Supporting SREG, AX, OAuth, UI, and PAPE extensions). It uses a callback-based asynchronous style and provides default in-memory storage for associations and discovered information, which can be overridden for persistent storage. The codebase shows signs of age but remains functional, with a test suite that includes integration tests against real OpenID providers.
gpt-review is a Python CLI tool that integrates OpenAI/Azure OpenAI models to assist with software development workflows. It provides three main functionalities: asking questions to GPT models (with optional file/context), reviewing GitHub pull requests and posting AI-generated comments, and generating git commit messages based on staged changes. The application uses a modular architecture with separate components for different functionalities: question answering (_ask.py), PR review (_review.py), git operations (_git.py), document indexing (_llama_index.py), and API wrappers (_openai.py). It leverages the knack library for CLI structure, GitPython for git operations, Requests for GitHub API calls, and LlamaIndex for context-aware queries. The tool supports both direct OpenAI API and Azure OpenAI with automatic fallback to Azure Key Vault for credentials.
This repository provides a complete Hyprland dotfiles configuration, including window manager settings, keybindings, theme management, and utility scripts for a Linux desktop environment. In production, it defines the entire user interface behavior: workspace switching via keybinds, floating window rules, power profile switching (battery vs AC), screen locking with swaylock, screenshotting with grim/slurp, and brightness/volume controls via scripts. The architecture is a collection of Hyprland config files, terminal (foot) config, fish shell functions, and shell scripts, all sourced from a main `hyprland.conf`. Themes are managed through separate branches and a base theme that uses a template-based approach to generate CSS for the ironbar taskbar dynamically. The system's external dependencies include Hyprland, foot, wofi, swaylock, grim, slurp, swww, fish, light, pamixer, asusctl (optional), and ironbar. This is not a library or service but a personal desktop configuration set; reusability of individual components is limited due to tight coupling with Hyprland and specific tool choices, though the theming script demonstrates a portable template substitution pattern.
This repository provides a jQuery plugin for smooth scrolling to same-page anchor links. It is a client-side library that enhances navigation by animating scroll behavior instead of instant jumps. The core implementation is in `src/jquery.smooth-scroll.js`, which extends jQuery with `$.fn.smoothScroll()` (for click binding on links) and `$.smoothScroll()` (for programmatic scrolling). It supports configurable offset, direction, speed, easing, exclusion rules, delegate selectors, auto-focus, and callbacks. The architecture follows the classic jQuery plugin pattern with UMD distribution, making it consumable via AMD, CommonJS, or global script tags. The codebase includes a QUnit test suite (`test/tests.js`) and demos showcasing various features. While the plugin is functionally complete and well-documented, it relies on an aging jQuery ecosystem (1.7+) and legacy build tools (Grunt). The code is clean and the helper functions for scrollable detection and relative offset parsing are reusable, but the overall project is no longer actively maintained and reflects a pre-ES6 era of web development. It remains a solid reference for jQuery plugin patterns but is not recommended for new projects due to jQuery's declining relevance.