Open Tournament is a first-person shooter game built on Unreal Engine, inspired by classic arena shooters like Unreal Tournament and Quake. The game implements comprehensive systems for player movement, combat, AI, user interface, audio, and networking. It features a modular architecture using Unreal Engine's plugin system, with extensive use of the Gameplay Ability System (GAS), Enhanced Input, and replication for multiplayer functionality. The codebase shows thoughtful architectural design in several reusable systems, particularly in settings management, UI composition, messaging, and loading screen handling.
This repository is a PHP client library for the Mautic marketing automation REST API. It provides a clean, object-oriented interface for performing CRUD and custom operations on Mautic entities such as contacts, campaigns, emails, segments, and companies. The library is built on PSR-18 (HTTP client) and PSR-7 (HTTP messages) abstractions, making it compatible with any modern PHP HTTP client via php-http/discovery. It supports three authentication methods: OAuth 1.0a, OAuth 2.0, and BasicAuth, each handling token lifecycle and refresh automatically. The architecture follows a factory pattern: the `MauticApi` class instantiates context-specific API classes (e.g., `Contacts`, `Emails`) that extend a common `Api` base class. The base class implements generic `get()`, `getList()`, `create()`, `edit()`, `delete()`, and batch operations, while context classes add custom endpoints (e.g., `addContact()` for campaigns). A fluent `QueryBuilder` allows building complex WHERE/ORDER/SELECT clauses for list requests. The library also includes a backwards-compatibility layer that transparently falls back to deprecated API URLs when a 404 is returned. External dependencies include any PSR-18 HTTP client implementation (e.g., Guzzle, Symfony HttpClient) and a PSR-3 logger (optional). The library is designed for integration into PHP applications that need programmatic access to Mautic data. It includes a legacy web-based API tester (`apitester/`) for manual testing, which vendors Bootstrap 3.2.0 and jQuery. The test suite requires a live Mautic instance and is run in CI against temporary installations. While the core library is modern and well-structured, the apitester UI is outdated and the backwards-compatibility layer introduces some technical debt. Overall, this is a solid, production-ready API client with good separation of concerns and reusable patterns.
This is an npm library that provides the GitHub GraphQL schema in JSON and IDL formats, along with a validation function and TypeScript type definitions. It is used by other Octokit libraries to validate GraphQL queries against the official GitHub GraphQL API. The schema is automatically updated hourly via a GitHub Action that fetches the latest schema from GitHub and creates pull requests for changes. The library is simple but robust, relying on the `graphql` package for validation and `graphql-codegen` for TypeScript types. It is not a data research project; it is a straightforward software library.
e18e/cli is a command-line tool that analyzes JavaScript and TypeScript projects for packaging issues, dependency health, and opportunities to replace dependencies with lighter or native alternatives. It runs multiple checks: publint for publishing best practices, dependency replacement suggestions from curated manifests (native, preferred, micro-utilities), core-js polyfill analysis against declared engine ranges, duplicate dependency detection, and web feature codemod suggestions. The CLI also includes a `migrate` subcommand that can automatically apply codemods to rewrite imports for selected replacements. The architecture is plugin-based: each analysis is a self-contained `ReportPlugin` that receives an `AnalysisContext` and returns messages and stats, aggregated by a `runPlugins` orchestrator. The tool uses an abstract `FileSystem` interface with a `LocalFileSystem` implementation, making it extensible for custom environments. Output is either an interactive TUI via @clack/prompts or JSON. This is a pre-1.0 project, actively developed with good code quality and comprehensive tests.
SuperAgentX is a modular, open-source multi-agent AI framework designed for orchestrating autonomous agents that plan, act, and execute real-world workflows. It supports 100+ LLM providers (OpenAI, Azure, Gemini, Claude, Bedrock, Ollama, LiteLLM) and 10,000+ MCP tools via the Model Context Protocol. The architecture centers on `AgentXPipe` pipelines that sequence or parallelize agents, each composed of an `Engine` that wraps an LLM client and a set of tool handlers. Handlers are defined using a `@tool` decorator pattern that auto-generates LLM function schemas. The framework includes built-in human-in-the-loop approval channels (console, Slack, Teams), persistent memory with SQLite and vector stores (Chroma, OpenSearch), full observability via OpenTelemetry and SQL-based telemetry, and a CLI for project scaffolding. It also features a production-grade browser automation engine based on Playwright for tasks where APIs are unavailable.
CATMAID (Collaborative Annotation Toolkit for Massive Amounts of Image Data) is a full-stack web application for collaborative connectomics research. It enables neuroscientists to trace neuron skeletons, annotate synapses, and analyze neural circuits across massive image stacks. The backend is a Django monolith with a REST API, PostgreSQL/PostGIS database, Celery for async tasks, and WebSockets for real-time collaboration. The frontend is a large JavaScript codebase using jQuery, Three.js, Pixi.js, D3, and custom widget system. Key features include skeleton tracing tools, 3D visualization, NBLAST neuron similarity, connectivity matrices, and review workflows. The codebase is well-structured with many reusable client-side utilities (event system, command pattern, caching, settings manager) and demonstrates strong engineering practices with CI/CD, tests, and Docker deployment. However, it carries some technical debt from vendored libraries and complex database migrations.
RVX is a fully functional RISC-V RV32I microcontroller IP core written in synthesizable Verilog, targeting FPGAs (specifically Digilent Arty A7 and Cmod A7 boards). It implements the RV32I base ISA v2.1 plus the Zicsr extension and Machine-Level ISA v1.13. The core includes a custom system bus (`rvx_bus`) that can be parameterized with an arbitrary number of memory-mapped slaves, and a set of peripherals: UART, GPIO, SPI, and machine timer (`mtime`/`mtimecmp`). The repository provides complete example projects for bare-metal and FreeRTOS, including board-specific wrapper modules, constraint files, and TCL scripts for Vivado project creation. The software examples use CMake with the RISC-V GCC toolchain and the `libsteel` hardware abstraction library. A comprehensive verification suite covers all RV32I instructions via RISC-V Architecture Test programs, alongside Cocotb-based peripheral tests and a Verilator simulation framework with C++ harness. The bus interface uses a simple request/response handshake with write strobes, which is clean but non-standard (not AXI/Wishbone). The core is a single-monolithic file (~1300 lines) with a 4-state FSM and no pipelining, making it compact but harder to modify. Overall, the repository is a well-documented, professionally structured open-source hardware project with strong testing practices, suitable for FPGA-based embedded systems education or low-complexity control applications.
FOSSLight Hub is an open-source compliance and security platform that manages open source software (OSS) inventories, licenses, vulnerabilities, and compliance workflows. It provides a web interface for OSS identification, license management, vulnerability tracking, self-check audits, SBOM generation (SPDX, CycloneDX), and supply chain management. The system is architected as a Spring Boot backend with MyBatis persistence, JWT-based authentication, and REST APIs (v2 and lite). It features a dual frontend: a legacy server-rendered UI using jqGrid and Thymeleaf, and a modern Next.js 'lite' client built with React, Tailwind CSS, and Recoil. Key entry points include API controllers (e.g., LiteOssController, ApiOssV2Controller), service layer components, and scheduled tasks for NVD/OSV vulnerability synchronization. External dependencies include MariaDB, a mail server, external license APIs (GitHub, ClearlyDefined), NVD/OSV vulnerability feeds, and the FOSSLight Scanner. The platform is actively developed with continuous releases and a growing feature set, though it carries some technical debt from legacy frontend libraries and enterprise-specific hardcoding.
This repository provides a set of Keycloak identity provider plugins for Russian social networks: Yandex, VK (legacy API), VK ID (new OAuth 2.0 with PKCE), Mail.Ru, and Odnoklassniki. It extends Keycloak's OAuth2 identity provider framework with custom endpoints, token exchange logic, user profile mapping, and admin UI themes. The architecture follows Keycloak's SPI pattern: each provider has a factory, config, identity provider class, and optional custom callback endpoint. Notable engineering includes PKCE support for VK ID, signature-based API authentication for Odnoklassniki, Basic Auth token exchange for Mail.Ru, and Infinispan-based state caching for VK ID's custom OAuth flow. The code is well-structured, uses modern Java 17 and Jakarta EE, and includes CI/CD pipelines for building and publishing to Maven Central. However, the repository lacks unit tests, which is a significant gap for a production-grade library.
This repository is a Laravel package that provides middleware for integrating with the IPinfo API to enrich HTTP requests with IP geolocation and related data. It supports multiple API tiers (Core, Plus, Lite, and Residential Proxy) and includes features like caching, IP selection strategies, bot filtering, and exception handling. The package follows Laravel conventions with service providers, facades, and configurable middleware. It is actively maintained with recent commits and supports Laravel versions up to 13. The codebase is well-structured, with clear separation of concerns and reusable components like the caching mechanism and IP selector interface.
Spiel is a terminal-based framework for creating and presenting slide decks using Python. It enables users to define slides as functions that return renderable objects (via Rich), and presents them in a navigable terminal user interface built with Textual. The framework supports features like live reloading during development, slide transitions, and dynamic content generation through a trigger system. The architecture centers around a `Deck` class that manages a sequence of `Slide` objects. Each slide's content is defined by a function that can optionally receive a `Triggers` object for time-based or interactive effects. The presentation is driven by a custom Textual application (`SpielApp`) that handles user input, screen transitions (including slide-to-slide animations), and automatic reloading of the deck when source files change. Key components include the CLI for launching presentations, a flexible slide definition system, and reusable widgets for rendering content such as syntax-highlighted code and images. Notable reusable components include the `Triggers` class for managing interactive state, the `Swipe` transition for slide animations, the `Image` widget for terminal image display, and a set of utility functions (`clamp`, `filter_join`, `chunks`) that solve common programming problems. These components are designed with low coupling and could be extracted for use in other projects with minimal modification.
Falkon is a Python library for large-scale kernel ridge regression and logistic regression, leveraging Nyström approximation and preconditioned conjugate gradient to scale to billions of points. It provides a scikit-learn-like API (fit/predict) with GPU acceleration via custom CUDA/cuBLAS/cuSOLVER kernels and optional KeOps integration for on-the-fly kernel-vector products. The library includes hyperparameter optimization through differentiable objectives (LOOCV, GCV, Nyström compression) with gradient-based solvers, out-of-core operations for GPU memory overflow, and sparse tensor support. Benchmark infrastructure compares Falkon against GPyTorch, GPflow, and EigenPro on datasets like Higgs, TIMIT, MillionSongs. The codebase is well-tested with CI/CD for CPU/GPU builds and pre-built wheels for multiple PyTorch/CUDA combinations. While the core library is production-grade, some benchmark scripts are one-off and a few modules have TODO comments or limited platform support (Linux-only, Windows untested).
Hyrax is a Ruby on Rails engine for building digital repository applications, part of the Samvera community. It provides core functionality for managing scholarly works, collections, file sets, and administrative sets with full lifecycle support: ingest, metadata management, access control (permissions, embargoes, leases), workflow (mediated deposit), analytics (GA4, Matomo), IIIF manifests, fixity checking, and derivatives generation. The architecture is a monolith with a modular actor middleware stack (chain of responsibility) for work creation/update/destroy, dry-transaction steps for resource operations, and a pub/sub event system for decoupled side effects. It supports dual persistence via ActiveFedora (Fedora) and Valkyrie (PostgreSQL, Fedora 6), with migration infrastructure (Wings, Freyja) and a Solr indexing layer. Key entry points include Rails controllers (Blacklight-based search, admin dashboard, API), the actor stack, and transaction steps. The codebase is heavily engineered with reusable patterns but carries significant technical debt from the ongoing migration to Valkyrie, deprecation warnings, and conditional code paths.
PySB is a Python framework for building and simulating rule-based mathematical models of biochemical systems. It provides a domain-specific language (DSL) embedded in Python for defining monomers, rules, parameters, and observables, with operator overloading to express reactions concisely. The library supports multiple simulation backends (SciPy ODE, BioNetGen, StochKit, Kappa, CUDA/OpenCL SSA, cupSODA) and can export models to SBML, MATLAB, Mathematica, BNGL, JSON, and other formats. It includes tools for sensitivity analysis, pattern matching, model testing, and parameter estimation. While primarily a software library, it also contains research examples, paper figure reproduction scripts, and experimental data, making it a hybrid project with a strong application core. The codebase is well-structured with clean abstractions (simulator base class, exporter registry, composable filter predicates) and extensive test coverage, though it carries some technical debt from deprecated modules and external tool dependencies.
This is a Hugo theme called "Lowkey" that provides a clean, modern styling for Hugo-generated static websites. Built with Tailwind CSS, it features a minimalist design with dark/light mode toggle, responsive layout, and specialized layouts for documentation sites. The theme includes reusable components like alert boxes, task lists, icon system, and theme-aware Mermaid diagram rendering. It's designed for blogs, portfolios, and documentation sites with features like friendly dates, syntax highlighting, and built-in SEO elements.
PullPreview is a GitHub Action implemented in Go that provisions ephemeral preview environments for pull requests. It manages cloud instances (AWS Lightsail or Hetzner), installs Docker or Kubernetes (k3s), and deploys applications using Docker Compose or Helm. The action integrates deeply with GitHub PR workflows: it reacts to labels, synchronizes SSH keys from repository collaborators, updates PR comments with deployment status and preview URLs, and performs scheduled cleanup of dangling instances. The codebase is organized around a provider abstraction pattern, with concrete implementations for Lightsail and Hetzner that share common orchestration logic for instance lifecycle, SSH access, and deployment. It is a self-contained CLI binary that runs as a composite action step, bundling all dependencies into a single executable.
nvim-test is a Neovim plugin that provides a unified interface for running tests across multiple programming languages. It integrates with Neovim's terminal system to execute test commands (like jest, pytest, etc.) and displays results in a split window. The plugin features language-specific runners that use tree-sitter queries to identify test functions and navigate to the nearest test from the cursor. Key components include a base Runner class for abstraction, utility functions for file path resolution, and terminal adapters for both built-in and toggleterm implementations. The plugin is actively maintained with recent commits and CI workflows, showing low technical debt as it relies on Neovim's stable APIs and external test runners without complex dependencies.
Collision is a desktop application for generating and verifying cryptographic hashes of files. Built with Crystal, GTK 4, and libadwaita, it provides a clean GUI interface to calculate MD5, SHA-1, SHA-256, SHA-512, Blake3, CRC32, and Adler32 hashes. The application features concurrent hash calculation using Crystal's fiber system, a Nautilus extension for file manager integration, and proper handling of Flatpak sandboxed environments. It follows a modular architecture with separate concerns for UI, core functionality, and application logic.
Mindolph is a desktop knowledge management application built with JavaFX. It provides integrated support for mind maps, markdown, PlantUML diagrams, and CSV files, along with AI-powered features such as text reframing, summarization, and chat via various LLM providers. The application features a modular architecture with core, base, FX, and domain-specific modules, an event-driven communication system, a plugin/extension system for mind map operations, and a preference management system. Users can manage workspaces, search within files, and use reusable snippets.
Shpod (Shell in a Pod) is a container image and Helm chart that provides a pre-configured shell environment with a comprehensive set of Kubernetes and container tools (kubectl, helm, kind, k9s, etc.). It is designed for training and debugging, allowing users to quickly get a shell with cluster-admin privileges inside a Kubernetes cluster. The repository contains a multi-stage Dockerfile that builds the image with architecture-aware downloads, a Helm chart for deployment with configurable RBAC, persistent volumes, and SSH access, and supporting shell scripts for initialization, Docker-in-Docker, and KinD cluster setup. The code is well-structured and demonstrates solid DevOps engineering practices, though it is a specialized tool rather than a general-purpose library.