This is the Meteora DLMM SDK monorepo: a production Solana concentrated-liquidity 'Liquidity Book' DEX protocol client. It contains a TypeScript SDK (`ts-client`), a Rust shared library (`commons`) and CLI (`cli`), a Python REST client (`python-client`), a market-making daemon (`market_making`), and an HTTP server wrapping DLMM operations. The core domain is bin-based concentrated liquidity: swap quoting, bin-array management, position creation/removal, limit orders, dynamic fees, reward claiming, oracle TWAP, rebalancing strategies, and Token-2022 transfer-fee/transfer-hook support. This is an application and SDK layer around an on-chain Anchor program, not a data/research repository.
This repository is a collection of Odoo Community Association (OCA) addons focused on extending accounting and invoicing functionality in Odoo. It provides over 50 modules that automate invoice processing, manage taxes and discounts, handle refunds and returns, integrate stock operations with invoicing, and enhance partner-specific invoicing workflows. Each module follows standard Odoo module structure with models, views, wizards, and data files, extending core Odoo models like account.move, sale.order, and stock.picking via inheritance. The modules are loosely coupled but may have interdependencies declared in their manifests. The system is designed to be installed within an Odoo instance, with entry points defined in each module's __init__.py and __manifest__.py files. Recent activity (last commit 2026-09-25) and active maintenance indicate a healthy project, though the wide version support (some modules targeting Odoo 9.0c-18.0) requires careful dependency management.
This is a Kodi video addon (plugin.video.themoviedb.helper) that provides rich metadata enrichment, browsing, discovery, player resolution, and synchronization for movies and TV shows. It integrates with multiple external APIs including TMDb, Trakt, TVDb, MDbList, FanartTV, OMDb, and Gemini AI. The architecture follows the Kodi addon pattern with three entry points: a plugin for directory listings, a background service for monitoring and scrobbling, and a script for one-off actions. The codebase is heavily modular with over 200 Python files organized into API wrappers, caching layers, database factories, sync engines, player configuration, and UI dialogs. It features extensive SQLite caching with thread-safe mutex locks, a custom import hook for API key permissions, and a flexible player resolution system based on JSON configuration files. While primarily an application, it includes significant data engineering patterns for caching, incremental syncing, and data transformation.
OpenMod is a .NET-based plugin framework designed for extensibility across game servers and applications. It provides core services including dependency injection, event handling, command processing, permission systems, user management, and configuration management. The framework features a modular architecture with platform-specific adapters for games like Unturned and Rust, enabling developers to create plugins that extend functionality without modifying the core. The system uses an event-driven approach for loose coupling and supports self-updating via NuGet package management. While primarily focused on game server modding, the core abstractions are general enough to apply to other extensible application scenarios.
This is a Neovim configuration distribution that provides a highly customized editing environment with a layer-based architecture inspired by Spacemacs. It implements a modular system where functionality is organized into layers (editor, ui, git, completion, devops) each containing their own configurations, keymappings, and plugins. The configuration uses lazy.nvim for plugin management, provides extensive LSP support, theme integration with dozens of color schemes, and keybindings following Spacemacs conventions using the spacebar as the leader key. The system loads user configuration from ~/.cosmos-nvim.lua with fallback to a sample configuration, processes layers to apply options and settings, registers keymappings with which-key.nvim, and manages plugins through lazy.nvim.
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 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.
The Khronos OpenCL ICD Loader is a system library that provides the OpenCL Installable Client Driver (ICD) discovery and dispatch mechanism. It exports the standard OpenCL API symbols (e.g., clGetPlatformIDs, clCreateContext) that applications link against. On Linux, it scans /etc/OpenCL/vendors for .icd files; on Windows, it queries the registry under HKLM\SOFTWARE\Khronos\OpenCL\Vendors and also supports DXGI adapters and AppPackage enumeration. It builds a dispatch table for each ICD and forwards API calls to the appropriate driver based on object handle dispatch pointers. The loader also supports an experimental layer mechanism that chains optional interceptor libraries. An optional command-line tool, cllayerinfo, lists available layers. The codebase is structured with platform-specific modules for library loading, environment variable parsing (with secure variants), and tracing (controlled by OCL_ICD_ENABLE_TRACE). A large portion of the dispatch code is generated via Mako templates from the official OpenCL XML registry, ensuring API completeness. The test suite uses a driver stub to validate correct dispatching across all OpenCL entry points.
Stimulus LSP is a TypeScript language server and VS Code extension that provides editor intelligence for Stimulus (Hotwire) controllers. The VS Code client (client/src/extension.ts) launches a vscode-languageclient over IPC and contributes a Stimulus controller tree view, while the standalone server (server/src/server.ts) implements the Language Server Protocol with completions, diagnostics, code actions, go-to-definition, code lenses and workspace commands. It handles HTML as well as template languages such as ERB, PHP and Blade by parsing markup with @herb-tools/language-service and scanning JavaScript/TypeScript controllers through stimulus-parser. At runtime the server builds a Project from the workspace root, detects installed Stimulus packages, analyzes controller files and feeds a custom HTML data provider so completions include controller identifiers, actions, targets and values. Diagnostics validate data-controller, data-action, data-target and data-value attributes plus controller source files, reporting missing controllers, invalid actions, value type mismatches and deprecated package imports; quick fixes can create, register or update controllers and write config entries. The code is organized into focused classes (Diagnostics, Definitions, Commands, CodeActions, CodeLens, Config, DocumentService), but there are visible defects: no automated tests are present, the e2e script points at a missing test output, one code-action branch is unreachable, and the data-target missing-diagnostic condition appears inverted. The repository is a solid reference for building LSP-based editor tooling for template-heavy frontend frameworks. It uses current LSP libraries and TypeScript, though it depends on a non-semver git-URL build of @hotwired/stimulus and declares a dependency on the same author's herb-lsp extension. A few internal utilities are generic enough to be reused independently.
This repository serves as the central documentation and community hub for the AboutCode family of open-source projects focused on software composition analysis (SCA). It hosts the documentation, contributing guidelines, release notes, and links to the actual code repositories for tools such as ScanCode Toolkit, VulnerableCode, DejaCode, and others. The repository is structured to build and maintain a static documentation site using Sphinx, integrated with Read the Docs for automated hosting. The codebase primarily consists of documentation source files (reStructuredText), Sphinx configuration, and standard project setup files (Makefile, configure scripts, etc.). It does not contain the functional code of the SCA tools themselves but provides the necessary infrastructure for documentation generation and community engagement. The project emphasizes clear contribution processes, code of conduct, and issue templates to facilitate collaboration. Despite being a documentation repository, it follows good software engineering practices with automated documentation builds, style checking (Doc8), and linting (Ruff) configured via GitHub workflows. The minimal actual code (setup scripts and configuration) is functional and maintainable, though it lacks highly reusable components beyond standard documentation project boilerplate. The repository is actively maintained, as evidenced by recent commits and ongoing workflow executions.
This repository is a clean-room reimplementation of the C64/C65/MEGA65 system ROMs, written primarily in 6502 assembly. It produces binary ROM images (e.g., `mega65_orfont.rom`, Kernal/BASIC ROMs) that can be flashed to hardware or used in emulators. The codebase is organized as a firmware source tree rather than a runtime application: `src/` contains the ROM source, `tools/` contains C/C++ utilities for verification and constant generation, and `testsuite/` contains TAP/D64 disk and tape images used as regression fixtures. The build is driven by platform-specific `config_*.s` files that select memory models and feature sets. It implements standard system software: a Kernal jump table, BASIC interpreter, machine-code monitor, keyboard scanner with debounce/repeat, tape/disk I/O, and a Z80 VM for CP/M compatibility. The project uses clean-room methodology: a similarity tool compares the new ROMs against original ROMs to detect accidental copying, and floating-point constants are generated from documented values rather than disassembled code. The test suite validates tape loading and disk access using standard `.tap` and `.d64` formats. Maintenance is active, but the codebase shows some internal drift: many `config_*.s` flags are not always consistent, and some modules carry WIP markers. The project is highly specialized to 6502-based retro platforms; most source is not portable outside that niche. However, several tools and patterns (binary similarity checking, code generation from specs, jump-table APIs, self-contained monitor) are reusable in other firmware or emulation projects.
Radiotray-NG is an internet radio player for Linux that runs in the system tray. It allows users to select and play configured radio stations, displays stream metadata, shows notifications, and provides control via system tray menu, media keys, or DBus. The application features a modular architecture with separate components for bookmarks management, configuration, event handling, playback (using GStreamer), playlist format handling, notifications, and GUI (with AppIndicator or ncurses fallback). It includes a bookmark editor GUI and supports sleep timer functionality.
This repository is a personal portfolio website built with React.js, featuring interactive components like a particle portrait, fractal tree animation, and 3D model viewer. The application uses Material-UI for UI components, React Router for navigation, and integrates libraries such as p5.js and three.js for visual effects. It presents a single-page layout with sections for introduction, experience, projects, and credits, utilizing custom scroll-based animations and responsive design. While the codebase demonstrates creativity in its interactive elements, it shows some inconsistency in component patterns (mixing class and functional components) and relies on outdated dependencies (React 16 and Material-UI v4).
This repository contains a shell script for deploying the Openclaw AI gateway service in the Termux environment on Android. It automates the installation of Node.js dependencies, applies compatibility patches to make Node.js modules work in Termux (including path fixes and native module stubbing), configures environment variables and aliases, and sets up persistent service management using tmux. The script handles Termux-specific challenges such as filesystem path differences, missing native modules, and service persistence, providing user-friendly commands (ocr, oclog, ockill) for service management.
envbuilder is a CLI tool written in Go that builds and runs Dev Containers (as defined by devcontainer.json) inside Docker containers, using a forked version of Kaniko for image building. In production, it clones a Git repository, locates a devcontainer.json or Dockerfile, compiles a Dockerfile with requested features, builds the image via Kaniko (with layer caching), and then executes lifecycle scripts (onCreate, postCreate, etc.) before running an init command as a specified user. It is designed to integrate with Coder workspaces for log forwarding but can operate standalone. The architecture is a single binary with modular components: options parsing (options/), Git operations (git/), devcontainer spec handling (devcontainer/), Kaniko build orchestration (envbuilder.go), and logging (log/). It relies on system calls for user switching (setuid), execution (exec), and filesystem mounts. External dependencies include Git, Docker daemon, and the Kaniko fork. The tool supports extensive configuration via CLI flags and environment variables, with legacy variable support. Key entry points are cmd/envbuilder/main.go (CLI) and envbuilder.go (Run function). The primary data flow is: input options -> clone repo -> parse devcontainer -> compile Dockerfile -> Kaniko build -> execute lifecycle scripts -> setuid -> exec init. The tool also includes a cache probe mode for checking layer availability without full build.
This repository implements a GitHub Action that triggers AWS CodeBuild builds. It starts a build using the AWS SDK, streams CloudWatch Logs to the GitHub Action output, and waits for the build to complete. The action handles rate limiting with exponential backoff and jitter, and supports cancelling builds via signal handling. The core logic is in `code-build.js`, which exports functions for building, waiting for completion, and processing inputs. The action is designed to be used in GitHub workflows but can also be run locally via the `local.js` script.
This is a Homebridge plugin (`@switchbot/homebridge-switchbot`) that bridges SwitchBot IoT devices (lights, curtains, locks, sensors, vacuums, etc.) into Apple HomeKit using both HAP and Matter protocols. It communicates via Bluetooth Low Energy (BLE) and the SwitchBot OpenAPI cloud API, with configurable fallback and rate-limiting. The plugin provides a rich configuration UI served through Homebridge Config UI X, including device discovery, credential management, and advanced polling settings. The architecture follows a platform plugin pattern with two platform classes (HAP and Matter), a resilient client layer (debounce, circuit breaker, daily budget tracking), a device factory and abstract base class for device-specific implementations, and extensive Matter cluster mappings. While the codebase is well-structured and actively maintained, it suffers from a large monolithic platform file (~2800 lines), low test coverage (~1.36%), and a dependency conflict requiring `--legacy-peer-deps` during installation. ESLint configuration also fails in CI. Nonetheless, the plugin is feature-rich, handles edge cases like BLE encryption and OpenAPI rate limits, and includes a polished custom UI.
WebTech is a Python-based tool for detecting technologies used on websites. It analyzes HTTP responses by examining headers, HTML content, meta tags, cookies, JavaScript, and URL patterns to identify web servers, frameworks, CMS, and other technologies. The tool provides both a command-line interface and a library API, with optional integration as a Burp Suite extension for active/passive scanning. Technology detection relies on a JSON-based signature database that is regularly updated from a Wappalyzer-compatible source. The architecture is modular, separating concerns into distinct modules: database management (downloading and merging signature files), HTML parsing (extracting meta tags and scripts), core detection logic (checking each technology signature across multiple vectors), and utility functions. The command-line tool processes single URLs or files containing multiple URLs, outputting results in human-readable, grep-friendly, or JSON formats. The Burp extension functions as a passive scanner, analyzing traffic intercepted by Burp Suite. While the core detection logic is well-structured and demonstrates reusable patterns, the codebase shows signs of technical debt. It maintains Python 2/3 compatibility (increasing burden as Python 2 is EOL), disables SSL verification by default (creating security risks), and the Burp extension depends on outdated Jython 2.7.0. The dependency on an external signature database introduces potential fragility if the upstream format changes. Despite these issues, the modular design allows for extraction of reusable components such as the Tech namedtuple, custom JSON encoder for sets, and HTML parser for meta/script extraction.
Nodehun is a Node.js native addon that provides bindings to the Hunspell spell checking library. It exposes Hunspell functionality through both synchronous and asynchronous APIs, enabling spell checking, suggestions, morphological analysis, and runtime dictionary management in Node.js applications. The architecture centers around a thread-safe Hunspell context using read-write locks to allow concurrent read operations, with asynchronous workers offloading intensive computations to libuv's thread pool. Key entry points include the Nodehun class initialization in src/index.cc and the async worker implementations in src/Async/. The system relies on the bundled Hunspell library (built from source) and N-API for Node.js version stability.
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.