O2OA is an open-source low-code development platform for enterprise collaborative office (OA) solutions. It features a JavaEE-based distributed architecture with a process engine, form/page customization, and business data services. The platform provides cross-platform support (Windows, Linux, Unix, ARM, etc.) and recommends production-ready databases like MySQL/Oracle/SQLServer. The system is organized into modular components including attendance, CMS, portal, process management, organization management, file handling, messaging, and AI integration. Backend uses Java with JAX-RS REST services, while frontend employs a custom MWF (O2OA Web Framework) alongside CKEditor for rich text editing. The architecture follows a layered approach with client-side UI components and server-side RESTful services, utilizing JPA for persistence and DTO patterns for data transfer.
TLPhotoPicker is an iOS library providing a customizable photo and video picker UI similar to Facebook's picker. It wraps the Photos framework (PHAsset, PHAssetCollection) and offers a configurable grid view with support for smart albums, live photos, video playback, iCloud download, and camera capture. The architecture follows a service-oriented pattern with separate classes for photo library access, selection logic, camera handling, and video playback, all coordinated by a central view controller. The library includes a builder pattern for configuration, async/await support for image loading, and comprehensive delegate callbacks. It is distributed via CocoaPods and Swift Package Manager, targeting iOS 13.0+. The codebase is well-structured but shows some technical drift, notably continued use of the deprecated UIImagePickerController for camera capture instead of the modern PHPickerViewController.
DelvUI is a Dalamud plugin for Final Fantasy XIV that provides a fully customizable replacement for the default HUD. It is a monolithic plugin that uses ImGui for rendering and hooks into game memory via FFXIVClientStructs to read player/party/encounter state. The architecture is heavily event-driven and singleton-based, with a central ConfigurationManager and HudManager that coordinate all HUD elements. The plugin implements a sophisticated attribute-driven configuration system that auto-generates ImGui settings panels from plain C# objects, enabling deep customization of bars, nameplates, party frames, job gauges, status effects, and more. It integrates with several other plugins via IPC (Honorific, PetRenamer, WhosTalking, Wotsit) and includes low-level hooks for pull timers, ready checks, and input interception. The codebase reflects strong engineering in its config abstraction and bar-drawing utilities, but also exhibits significant maintenance debt from hardcoded game IDs, reflection-heavy design, and pervasive singleton use.
CrystalEngine is a full-featured, cross-platform game engine with an integrated editor, built from scratch in C++. It features a custom Vulkan/Metal rendering backend with a directed acyclic frame graph for render pass scheduling, a physically-based rendering pipeline with IBL and shadow mapping, and a modular architecture with dynamic module loading. The engine includes a comprehensive asset pipeline (import, compression, serialization), a job system for parallelism, and a physics integration via Jolt. A notable aspect is the dual UI framework: the older CrystalWidgets (CSS-styled) and the newer Fusion framework (declarative, property-based), both used in the editor. The editor provides dockable windows, property editors, material editing, scene outliner, and asset browser. The codebase demonstrates strong engineering with clean abstractions (RHI, RPI, frame graph, job system) but shows signs of ongoing migration (two UI frameworks) and some incomplete features. It is actively maintained and suitable for learning or extending a modern game engine architecture.
This repository is a Next.js application demonstrating the use of the OpenAI Realtime API via WebRTC for real-time voice interaction with a 3D solar system scene built in Spline. The application allows users to ask questions about the solar system, moons, the ISS position, and data visualizations, which trigger function calls to update the 3D scene or display charts in the UI. The architecture consists of a frontend built with React and Next.js, featuring components for the 3D scene (using @splinetool/react-spline), controls for managing the WebRTC connection, and a debug log. Two API routes proxy requests to external services: one for fetching the ISS position and another for obtaining ephemeral client secrets from the OpenAI Realtime API. The frontend establishes a WebRTC connection to OpenAI, sends audio input, and processes function call responses to trigger animations in the Spline scene or update the UI with charts. A notable reusable component is the charting system located in `components/charts/chart.tsx`, which provides a set of theme-aware, flexible charting components (Container, Tooltip, Legend) that abstract the complexity of integrating Recharts and Chart.js with Tailwind CSS. This component demonstrates a clean separation of concerns and can be adapted for use in other projects with minimal modification. The rest of the codebase is tailored to the solar system demo but follows modern React and Next.js best practices, including TypeScript strict mode, proper error handling, and modular organization. The application is actively maintained, with recent commits and up-to-date dependencies, and exhibits low technical drift, adhering to current web standards and APIs.
wego is a terminal weather client that fetches data from multiple weather APIs and displays it in various formats. It features a plugin architecture that allows easy addition of new backends (weather data sources) and frontends (output formats). The application handles configuration via environment variables, config files, and command-line flags, with caching to reduce API calls.
Go by Example δΈζη is a static site generator that produces a Chinese-language tutorial website for Go programming. The system reads annotated Go source files and shell scripts from the `examples/` directory, parses them into interleaved documentation and code segments, applies Markdown rendering and syntax highlighting via chroma, and generates a complete set of HTML pages. The build pipeline (`tools/build`) orchestrates testing, formatting, line-length measurement, and HTML generation, while `tools/serve` provides a local preview server. The site is deployed to S3 using a dedicated upload script. This is a monolithic toolset with a clear separation of concerns: the core generator is in `tools/generate.go`, templates are in `templates/`, and static assets are served directly. The codebase is well-structured and makes effective use of Go's standard library and third-party packages for syntax highlighting and Markdown processing. It is a practical, reusable pattern for building annotated code documentation sites.
This repository is a Node.js library for interacting with the Windows registry. It provides functions to read, write, list, and manipulate registry keys and values using Windows Script Host (cscript.exe) and VBScript. The architecture separates concerns: Node.js handles argument parsing, process spawning, and result parsing, while VBScript files perform the actual registry operations via WMI. The library supports both callback and promise-based APIs, handles different registry value types, provides 32/64-bit registry access options, and includes streaming interfaces for large operations. It's a focused, well-tested solution for a specific platform-specific problem.
Ersilia is a Python CLI and library that manages the lifecycle of pre-trained AI/ML models for drug discovery and biomedical research. It fetches model bundles from DockerHub, GitHub, S3, or hosted endpoints, serves them locally via Docker, Conda, venv, or system processes, exposes a standardized prediction API (CSV/JSON/CLI), and provides batch inference, caching, and model run tracking. The codebase is explicitly engineered as a model-hub client: a rich Click CLI (`ersilia fetch/serve/run/close/catalog`), a mirroring Python API (`ersilia.api.Model` and `ersilia.api.Catalog`), session management, service abstractions, input/output adapters for chemical compounds, proteins, and text, and a publishing/QA pipeline for onboarding new models. It is not a data analysis or notebook repository despite the scientific domain; the dominant character is a software application with infrastructure for model distribution and execution. The architecture is modular but heavily interconnected: `ErsiliaModel` orchestrates fetch, serve, run, and close; `ModelFetcher` composes actions (prepare, get, pack, register); `AutoService` selects among Docker, Conda, venv, system, and hosted backends; `StandardCSVRunApi` handles batched, streaming, and cached inference. Strengths include a well-structured exception hierarchy, reusable environment wrappers (`SimpleDocker`, `SimpleConda`, `SimpleVenv`), controlled metadata vocabularies, and an extensive test suite. Weaknesses include scattered hardcoded external URLs, partial cloud deployer implementations, mixed sync/async code, and some unfinished features or duplicated validation logic. The project is actively maintained (recent commits, CI workflows) and has a strong release pipeline, but its heavy reliance on external services and subprocess-based environment management makes it brittle across platforms. Overall it is a functional, valuable tool for biomedical researchers, with clean enough abstractions to be instructive, though reuse is constrained by its domain-specific model-hub concepts.
This repository provides an HTTP API service for interacting with the TON (The Open Network) blockchain. It acts as an intermediary, translating HTTP requests into calls to the TON blockchain via the tonlib library. The service is built with FastAPI and uses a pool of worker processes to communicate with TON nodes, handling load balancing and failover. It supports caching of responses via Redis to reduce load on the blockchain nodes. The service exposes both REST and JSON-RPC endpoints for a wide range of blockchain operations, including querying account information, executing smart contract methods, and sending transactions.
This repository hosts the landing page for ClawSweeper, a conservative maintenance bot for OpenClaw repositories. It is a single-page static site built with handcrafted HTML and CSS, deployed on Vercel. The page describes the bot's purpose, operating lanes, guardrails, and watched repositories. The codebase is minimal but exhibits high craftsmanship in its editorial dark theme, responsive design, and accessibility features. The included GitHub Actions workflow dispatches events to the actual ClawSweeper bot repository, enabling automated review triggers. This is not the bot itself; the bot lives in a separate repository (openclaw/clawsweeper). The landing page is well-maintained and serves as a polished informational site.
SDPO (Self-Distilled Policy Optimization) is a framework for training large language models using reinforcement learning algorithms, built upon the verl (Volcano Engine Reinforcement Learning) foundation. The system provides a modular architecture for implementing PPO, GRPO, SDPO, and other RL algorithms with distributed training capabilities via Ray. It integrates with inference engines like vLLM and SGLang, supports multiple model architectures (Llama, Qwen with Megatron optimization), and includes reward modeling for domains like mathematics and coding. The framework features extensible components for reward managers, tools, and agent interactions, with experimental capabilities for fully asynchronous training and multi-turn reasoning. While actively maintained, the system's complexity and extensive dependency ecosystem present moderate technical drift risks.
SymTorch is a Python library for deep learning interpretability via symbolic regression. It wraps PyTorch neural network components (layers, submodules) or arbitrary callable functions (e.g., LLM inference, scikit-learn models) and uses the PySR symbolic regression engine (Julia-backed) to discover human-readable mathematical equations that approximate the wrapped component's input-output behavior. The library provides a unified SymbolicModel class that can operate at the layer level (using forward hooks to capture intermediate activations) or in a model-agnostic mode for any black-box function. It also supports local interpretability via SLIME (synthetic neighborhood sampling with weighted regression) and progressive dimensionality reduction through configurable pruning schedules (exponential, linear, cosine decay). The primary workflow involves wrapping a model, optionally training with pruning, calling distill() to run symbolic regression, inspecting discovered equations via show_symbolic_expression(), and optionally switching the forward pass to use the symbolic equation instead of the original block via switch_to_symbolic(). The architecture is monolithic: the SymbolicModel class (~2300 lines) encapsulates all functionality including caching, PySR parameter management, forward hook handling, SLIME sampling, pruning schedules, and serialization via dill. While this centralization simplifies the public API, it creates a single point of maintenance and limits modular reuse. The library relies on several heavy external dependencies: PySR (which requires Julia), PyTorch, SymPy, and dill. Documentation includes comprehensive API reference, Jupyter notebook demos (PINNs, GNNs, LLM arithmetic probing), and case studies demonstrating symbolic extraction from physics-informed neural networks and small language models. The codebase demonstrates solid engineering with good docstrings, extensive caching to avoid redundant computations, and thoughtful design decisions like configurable pruning schedules and SLIME parameters. However, there are signs of academic development: future-dated version numbers (1.1.1 docs vs 1.0.1.post1 setup.py), local path references in demos, and incomplete decomposition (TODO comments about breaking up the class). The testing suite exists but heavily mocks PySR, which may miss integration issues. Overall, SymTorch is a functional, research-oriented interpretability toolkit with clear value for extracting symbolic equations from trained models, but its monolithic structure and external dependencies limit its reuse as a standalone component.
The Apache Dubbo website repository hosts the source code for the official Apache Dubbo project website. It is built using the Hugo static site generator with the Docsy theme, providing documentation in multiple languages and versions. The repository also includes a self-contained Vue.js benchmark application for visualizing Dubbo performance data, along with reusable search and glossary functionalities for the documentation site. The site is deployed via GitHub Actions to GitHub Pages.
NextChat (formerly ChatGPT-Next-Web) is a production-grade, multi-model AI chat client built with Next.js 14 and React 18. It serves as a unified frontend for over 15 LLM providers (OpenAI, Azure, Anthropic, Google, Baidu, ByteDance, DeepSeek, etc.) with a consistent chat interface. The system operates as a full-stack Next.js application: server API routes act as secure proxies to third-party LLM endpoints, while the client-side uses Zustand for state management with IndexedDB persistence and cloud synchronization (WebDAV, Upstash). The architecture supports multiple deployment modes including web (Vercel/Zeabur), self-hosted (Docker), and native desktop via Tauri. Key features include real-time streaming responses with tool calling, Model Context Protocol (MCP) integration for third-party tools, text-to-speech, export/share mechanisms, and a plugin system based on OpenAPI specifications. The codebase is extensive with reusable patterns for fetch adaption, state persistence, markdown rendering, and MCP client management.
This repository provides an end-to-end reinforcement learning framework for Unitree legged robots (Go2, G1, H1, H2, A2, AS2, R1). It uses MuJoCo physics (via the custom `mjlab` package) to simulate locomotion and motion imitation tasks. The codebase includes training scripts (`scripts/train.py`) that run PPO (from `rsl_rl`) with configurable network architectures and multi-GPU support, exporting trained policies to ONNX format. The `deploy/` directory contains C++ applications that execute these policies on real hardware using ONNX Runtime and Unitree SDK2, orchestrated by a finite state machine. The system is split into two main tasks: velocity tracking (gait generation) and motion tracking (whole-body imitation from reference trajectories). Key architectural patterns include manager-based environment configuration, composable MDP terms (rewards, observations, terminations), curriculum learning, and a YAML-driven FSM for deployment. The repository is actively maintained, with recent commits and bundled third-party dependencies (MuJoCo binaries, ONNX Runtime) for cross-platform deployment.
This repository provides board support packages for the LiteX open-source FPGA SoC builder. It contains over 150 platform definitions (pinouts, connectors, toolchain setup) and corresponding target scripts that assemble a complete SoC (CPU, memory, peripherals) for each FPGA board. The architecture is a collection of Python modules organized into `litex_boards/platforms/` and `litex_boards/targets/`, with each target being a standalone script that can be invoked via `python -m litex_boards.targets.<board> --build --load`. The system supports a wide range of FPGA families (Xilinx, Lattice, Intel/Altera, Gowin, Efinix, CologneChip) and integrates with the broader LiteX ecosystem (LiteDRAM, LiteEth, LitePCIe, etc.) for memory controllers, networking, and high-speed interfaces. Key entry points are the `main()` functions in each target file, which use `LiteXArgumentParser` for CLI argument handling and `Builder` for bitstream generation. The repository is community-maintained under litex-hub and includes CI scripts for consistency checks, board inventory generation, and regression tests.
EGO is a Go microservices framework designed around component-based lifecycle management. It provides servers (HTTP via Gin, gRPC), clients (HTTP, gRPC), scheduled tasks (cron, one-off jobs), and built-in observability (structured logging, Prometheus metrics, OpenTelemetry tracing). The framework uses a configuration-driven pattern (Load β Build) and includes protoc plugins for generating error types, HTTP handlers, and test scaffolding. Production usage typically involves defining components in TOML/YAML config files and wiring them via the ego.New().Serve(...) entry point. The architecture is modular with clear abstractions for configuration, logging, metrics, registry, and resilient interceptors.
Stripe-ruby-mock is a Ruby library that provides in-memory mocking of the Stripe API for testing purposes. It intercepts Stripe HTTP requests and returns simulated responses, enabling offline, deterministic testing without real API keys or network access. The library supports both local mocking (via `StripeMock.start`/`stop`) and a remote mock server for integration tests across processes. It covers a wide range of Stripe endpoints including charges, customers, subscriptions, invoices, payment intents, and webhooks, with extensive shared RSpec examples and webhook fixtures. The architecture follows a modular request-handler pattern, with helpers for token generation, param validation, and search simulation. While the codebase is well-structured and popular (996 stars), it shows signs of maintenance strain (199 open issues, call for core maintainers) and technical drift (vendored Trollop CLI parser, outdated webhook fixtures, limited Stripe API version coverage). It remains a valuable tool for legacy Stripe testing but may require updates to fully align with current Stripe API changes.
Nova Proximity is a modular Python security scanner designed specifically for MCP (Model Context Protocol) servers and Agent Skills. The application provides comprehensive discovery and analysis capabilities, including tool/prompt/resource enumeration for MCP servers and structural/permission analysis for Agent Skills. Its architecture separates concerns into distinct libraries: mcp_scanner_lib for MCP protocol handling, skill_scanner_lib for Agent Skills analysis, and nova_evaluator_lib for NOVA-powered security evaluation. The tool supports multiple transport mechanisms (stdio, SSE, Streamable HTTP) with automatic fallback, provides detailed function signature analysis, and generates actionable security reports with pattern-specific remediation guidance.