jira.js is a comprehensive TypeScript SDK for Atlassian Jira REST APIs, covering Cloud, Data Center, Agile, Service Management, Assets, Administration, Teams, User Management, and User Provisioning surfaces. It is designed as a modular library with separate client factories (e.g., createCloudClient, createServerClient, createAgileClient) that provide typed access to hundreds of API endpoints. The architecture is built on a core transport layer that handles authentication (basic, bearer, OAuth 2.0), request/response validation using Zod schemas, error classification, retry logic, and multipart form data. Every API response is validated at runtime, with configurable behavior on schema mismatch (warn, throw, silent) and an optional audit mode to detect API drift. The library is primarily generated from Atlassian's OpenAPI specifications, resulting in a large, consistent codebase with models, parameters, and API functions organized by product domain. Key entry points include the client factories and subpath imports like 'jira.js/cloud' or 'jira.js/agile'. Data flows are straightforward: consumers construct typed request options and call client.sendRequest(), which returns validated response objects. External dependencies are minimal: zod for runtime validation, and the platform's fetch API for HTTP. The library also includes webhook signature verification, OAuth 2.0 (3LO) helpers for both Cloud and Data Center, and a browser-compatible bundle. Notable patterns include the use of apiObject and openEnum helpers to create Zod schemas that are permissive by default but strict under audit, enabling graceful handling of API evolution. The error hierarchy uses branded symbols for reliable type guards across package copies. The test suite includes extensive live integration tests against real Atlassian instances, with resource tracking and entitlement-aware gating. Overall, jira.js is a well-engineered, actively maintained SDK that prioritizes type safety and runtime validation, though its large generated surface introduces some duplication and maintenance overhead.
junixsocket is a Java/JNI library providing Unix domain socket (AF_UNIX) support and other advanced socket families (AF_TIPC, AF_VSOCK, AF_SYSTEM) to Java applications. It extends standard Java Socket and NIO APIs with features like ancillary data (file descriptor passing), peer credentials, abstract namespace, SSL/TLS, RMI, and shared memory. The architecture is modular with core modules (junixsocket-common, junixsocket-native) and protocol-specific extensions. Key entry points include factory methods in AFUNIXSocket/AFUNIXServerSocket, SSLContextBuilder, and AFUNIXNaming. Data flows involve JNI-mediated socket operations for IPC, with advanced features using native ancillary messaging. External dependencies include optional integrations (MySQL Connector/J, Jetty, Netty) and platform-specific toolchains for native builds.
The rstatix package provides a simple and intuitive pipe-friendly framework for performing basic statistical tests and data analysis. It includes functions for t-tests, ANOVA, Wilcoxon tests, correlation tests, and more. The package is designed to be easy to use and integrates with the tidyverse design philosophy.
Direktiv is a workflow automation and serverless orchestration platform that enables users to define, execute, and manage workflows and services through a web UI or API. The system features a Go-based backend with React/TypeScript frontend, providing namespace-based multi-tenancy, event-driven triggers via CloudEvents and NATS, a plugin-extensible API gateway, and Kubernetes-native service deployment. Key capabilities include workflow execution (YAML/TypeScript), service management, secret/variable storage, file handling, Git-based namespace mirroring, and comprehensive monitoring with OpenTelemetry integration. The architecture follows a microservices-inspired monolith pattern with clear separation between API handling, data storage, execution engine, and gateway plugin systems.
Gavel is a Flask-based web application designed for ranking projects at events like hackathons using pairwise comparisons. The system presents judges with pairs of projects to compare, updating rankings in real-time via a Bayesian inference algorithm. Key components include a custom SQLAlchemy class for serializable transaction isolation, a standalone ranking algorithm module (crowd_bt.py), and utility functions for data handling and security. The application uses PostgreSQL for data storage, Celery for asynchronous email tasks, and relies on Redis as a message broker. Admin interfaces allow managing projects, judges, and global settings, with real-time updates to project rankings displayed via the Mu parameter.
This repository is a Homebridge plugin for Xiaomi Miot devices, allowing control of various smart home devices through Homekit. It supports a wide range of device types, including fans, heaters, humidifiers, air purifiers, and more. The plugin integrates Miot devices into Homekit, enabling control from the native Homekit iOS app and Siri.
OpenCowork is a desktop AI agent application built with Electron, React, and TypeScript. It enables users to automate tasks through natural language interactions, supporting browser automation (via Playwright), local command execution, image processing, and integration with messaging platforms like Feishu. The application features a modular architecture with separate main and renderer processes, communicating via IPC. Core functionality includes task orchestration, skill-based workflow reuse, scheduling, memory management, and MCP (Model Context Protocol) integration for extensibility. The system emphasizes local-first operation, user control, and reliable execution with fallback mechanisms for unstable automation scenarios.
This repository is a developer toolchain for creating custom node graph logic in Genshin Impact's UGC mode (Miliastra Wonderland). It compiles a subset of TypeScript into a binary GIA format (protobuf) and injects it into game map files (.gil). The system includes a CLI (gsts) for build/inject/watch, a multi-stage compiler (TS → GS intermediate → IR JSON → GIA), an injector that patches save files, and a comprehensive set of custom ESLint rules enforcing the supported TypeScript subset. It supports both server-side and client-side node graphs with two modes (classic and beyond), and provides extensive type definitions, bilingual support (Chinese/English), and auto-generated tests covering thousands of node combinations. The codebase demonstrates strong engineering practices: rigorous testing, type safety, i18n, and modular architecture. However, it depends heavily on reverse-engineered game data (node IDs, pin records, protobuf schemas) that must be updated with each game patch, and some components are tightly coupled to internal definitions.
OpenClaw AWD Arena is a comprehensive platform for conducting Attack-With-Defense (AWD) cybersecurity competitions, specifically designed for training and evaluating large language models (LLMs) in offensive and defensive security scenarios. The system orchestrates isolated Docker container environments where each participant (LLM agent or human) runs a vulnerable service that must be defended while attempting to capture flags from opponents' services. It features a web-based interface for match configuration and real-time monitoring, a Python/FastAPI backend handling game logic, scoring, and WebSocket-based event streaming, and custom orchestration logic for managing the lifecycle of match environments. The platform includes built-in flag management, scoring systems, match replay functionality, and support for multiple agent backends via a plugin architecture.
Image MetaHub is a local-first Electron desktop application for organizing, browsing, and re-generating AI-generated images. It indexes media files in place (no uploads, no moving files) and extracts structured metadata — prompts, models, LoRAs, samplers, seeds, workflows — from 15+ generators including ComfyUI, A1111, InvokeAI, Midjourney, DALL-E, Fooocus, and Adobe Firefly (via C2PA/JUMBF/CBOR parsing). Beyond images it handles video, audio, and 3D model metadata. The app provides tagging, collections, automation rules, ratings, analytics, image comparison with pixel-level diffing, lineage/provenance tracking, and integration with local ComfyUI/A1111 instances for re-generation and upscaling. Pro features (visual search, clustering, batch export) are gated by an offline license system with a 7-day trial and Stripe billing.
Pelican Wings is a production-grade game server management daemon (agent) built in Go. It serves as the control plane for the Pelican Panel, managing Docker containers that run game servers. The daemon exposes a comprehensive HTTP API for server lifecycle operations (start, stop, install, backup, transfer), real-time WebSocket streams for console output and server stats, and a built-in SFTP server for file management. It communicates with a remote Panel API to synchronize server configurations, validate user credentials, and report activity logs. The codebase demonstrates strong systems engineering with a focus on security (sandboxed filesystem using openat2 syscalls, token authentication, download IP filtering), performance (disk-space caching, atomic generics), and reliability (crash detection, state persistence, cron-based backups). It supports multiple backup backends (local disk, S3), parallel server bootstrapping, and self-update via GitHub releases. The architecture follows a modular pattern with clear separation between API routing, server management, filesystem operations, and integration adapters. While the code is a fork of Pterodactyl Wings with some incomplete rebranding, it remains actively developed and production-ready.
Decman is a declarative package and configuration manager for Arch Linux that ensures system state matches user-defined specifications. It uses a modular architecture with a core application and plugins for managing different subsystems (pacman, AUR, systemd, flatpak). Users define their desired system state in Python files, and Decman executes these specifications to install/remove packages, manage files and directories, enable/disable services, and apply other system configurations. The system tracks its state in a JSON store to determine what changes are needed between runs, and provides hook functions for custom logic at various points in the execution lifecycle.
The GodotSharp.SourceGenerators repository provides a set of Roslyn source generators designed to enhance the Godot Engine C# development experience. These generators inspect C# source code for specific attributes (such as `[SceneTree]`, `[AnimNames]`, `[AudioBus]`, etc.) and generate corresponding strongly-typed accessor code, eliminating the need for magic strings and improving compile-time safety. The project supports both Godot 3 and Godot 4 versions, with a clear migration path outlined in the documentation. The architecture follows a modular pattern where each feature (e.g., scene tree access, animation names) is implemented as a separate extension. Each extension consists of an attribute, a data model, a scraper to extract information from the project and source files, a source generator that uses Scriban templates to produce C# code, and the template itself. Shared utilities handle common tasks such as path resolution, string manipulation, and unique ID generation, promoting code reuse and consistency across generators. The repository includes extensive test suites for both Godot 3 and 4, validating the generated code against various scenarios including inheritance, same-name handling, nullable reference types, and edge cases. This ensures the generators remain robust despite Godot's evolving API. The project is actively maintained, with recent commits and a structured approach to handling breaking changes between versions.
FlagAttention is a library implementing memory-efficient attention operators in the Triton language. It provides optimized implementations of flash attention, piecewise attention, paged attention, and gated delta rule operations, designed for use in large language model training and inference. The library features modular architecture with separate implementations for each attention variant, comprehensive testing, and example usage patterns. It leverages Triton for GPU-accelerated computations while maintaining compatibility with PyTorch's autograd system.
react-native-nitro-markdown is a high-performance native Markdown parser and renderer for React Native, built on a vendored md4c C library (forked as nitromd) and the Nitro Modules framework for direct JSI bridging. It provides full CommonMark and GitHub Flavored Markdown support, plus extensions for LaTeX inline/block math, task lists, and strikethrough. The library offers three primary consumption modes: a full `<Markdown>` React component with customizable renderers, a `<MarkdownStream>` component designed for progressive rendering of streaming text (e.g., from LLM output), and a headless API (`parseMarkdown`, `extractPlainText`, `createMarkdownSession`) for server-side or non-React usage. Architecture is layered: native C++ parser produces a typed JSON AST, which is consumed by a React rendering pipeline with caching, incremental updates, and a plugin system. The repository includes a comprehensive test suite (unit, conformance, snapshot, C++ unit, E2E Maestro), performance benchmarks, fuzz testing, and a CI/CD pipeline for automated releases. It is a mature, well-engineered library with strong focus on correctness, performance, and developer experience, though it is tightly coupled to the iOS/Android native runtime and Nitro Modules ecosystem.
This repository is the Meteora DLMM (Dynamic Liquidity Market Maker) SDK, a comprehensive multi-language toolkit for interacting with the Meteora concentrated liquidity AMM protocol on Solana. The system includes a Rust core library (`commons/`) with swap quoting, fee calculation, PDA derivation, and math utilities; a TypeScript client (`ts-client/`) that provides a high-level `DLMM` class for pool interaction, liquidity management, rebalancing, and limit orders; a Rust CLI for admin and user operations; a Python client that wraps the TypeScript SDK via a REST API; and a market-making bot example. The on-chain program is defined in IDL files with over 50 instructions supporting multiple pool types (permissionless, permissioned, customizable), Token-2022 with transfer hooks, and advanced features like volatility-based dynamic fees and oracle TWAP. Architecturally, the SDK is layered: the Rust `commons` crate contains the core business logic and is reused by the CLI and market-making bot, while the TypeScript client reimplements much of this logic for off-chain use. The CLI serves as a reference implementation for all protocol operations. The market-making bot demonstrates automated position rebalancing using configurable strategies. The Python client is a thin wrapper that delegates to a TypeScript server, making it less independent. The codebase is heavily tested with Rust integration tests and TypeScript unit tests, including property-based tests for bid-ask math and Token-2022 compatibility. The primary data flows are: user requests (swap, add/remove liquidity, claim fees) go through the client SDK, which constructs and signs transactions for the Meteora DLMM on-chain program. The SDK computes quotes off-chain, simulates rebalancing, and derives required accounts. The market-making bot periodically fetches pool state, evaluates active price drift, and executes rebalancing transactions. The codebase demonstrates strong engineering practices with clear separation of concerns, reusable math utilities, and consistent patterns across languages.
This is a Python library for quantitative finance, specifically portfolio optimization and risk management. It implements Conditional Value-at-Risk (CVaR) optimization using Benders decomposition, mean-variance optimization via quadratic programming, and entropy pooling for adjusting scenario probabilities under user-defined views and stress tests. The library also includes fully flexible resampling (FFR) for simulation, Black's model for option pricing, and a set of helper functions for financial statistics. It is designed as a monolithic Python package with a clean API, extensive tests (100% coverage), and 14 Jupyter notebooks that serve as reproducible examples. While the primary character is an application library, it has a strong research and educational orientation, referencing academic papers and providing walkthroughs. The code is well-structured, but domain-specific and depends on cvxopt with GLPK for linear programming, which may limit portability.
libsystemctlm-soc is a SystemC/TLM-2.0 based library for hardware verification and co-simulation, primarily targeting Xilinx/AMD platforms. It provides a comprehensive framework for modeling, verifying, and testing AMBA-based protocols (AXI, ACE, CHI) and PCIe interfaces through traffic generation, protocol checking, and hardware/software bridging capabilities. The architecture is modular with clear separation between communication layers (libremote-port), platform-specific implementations (soc), protocol bridges (tlm-bridges), utility components (tlm-modules), traffic generators, and verification infrastructure. Rather than a standalone application, it functions as a reusable library/framework that engineers integrate into their verification environments to create testbenches for SoC designs, enabling co-simulation between CPU models (via QEMU) and FPGA/ASIC models.
sbomqs is a command-line tool and Go library for evaluating the quality and compliance of Software Bill of Materials (SBOM) documents. It parses SBOMs in CycloneDX, SPDX 2.x, and SPDX 3.0 formats and scores them against multiple industry standards: NTIA Minimum Elements (2021/2025/2026), BSI TR-03183-2 (v1.1, v2.0, v2.1), FSCT v3, OpenChain Telco v1.1, and an Interlynk comprehensive profile. The tool outputs scores, detailed compliance reports, and feature lists, and can be integrated with Dependency-Track and policy engines. It is used in production by several platforms and has been cited in academic research evaluating over 78,000 SBOMs. The codebase is well-structured with clean interfaces, extensive test coverage, and a modular architecture that separates parsing, scoring, compliance checking, and reporting. A notable architectural trade-off is the coexistence of two scoring engines (legacy v1 and v2), which adds complexity but allows incremental migration. The library is embeddable as a Go module, and the CLI supports multiple output formats (basic, detailed, JSON).
Hecke.jl is a Julia package for computational algebraic number theory, forming a core component of the OSCAR computer algebra system. It provides a comprehensive suite of algorithms for number fields (absolute, relative, simple, non-simple), orders and ideals, class groups, unit groups, elliptic curves (including isogenies, heights, pairings), quadratic and Hermitian forms, local fields, function fields, associative algebras, and Riemann surfaces. The architecture is modular, with separate source files for each algebraic structure, extensive use of caching via attributes, and integration with GAP and Polymake for group-theoretic and polyhedral computations. The library is designed for research mathematicians and relies on the Nemo/AbstractAlgebra ecosystem for base ring infrastructure. The codebase is large (875 files) and well-tested, with a dedicated test suite covering most modules. It includes reusable components such as sparse matrix types, AVL trees, generic map infrastructure, and factored element representations. The package is actively maintained, with recent commits, CI pipelines, and a changelog documenting ongoing development. While some parts are experimental or contain commented-out code, the core algorithms are production-grade and used in research publications. Hecke.jl is primarily a library (application) rather than a data pipeline, though it includes example scripts and benchmarks that demonstrate research workflows. Its primary purpose is to provide efficient, rigorous implementations of number-theoretic algorithms for use by mathematicians and computer algebra systems.