OASIS is a Python framework for simulating social media platforms (Twitter, Reddit) populated by LLM-powered agents. It is designed for computational social science research, specifically studying information spread, opinion dynamics, group polarization, and the impact of platform algorithms. The system is built on top of the CAMEL AI framework for LLM interaction. The architecture follows a modular, event-driven pattern. The core simulation loop is managed by OasisEnv, which coordinates agents (SocialAgent), a platform (Platform), an async message channel (Channel), and a social graph (AgentGraph). Actions are generated by agents (either manually or via LLM calls), passed through the channel, and executed by the platform against a SQLite database. A recommendation system (Recsys) provides personalized content feeds using various strategies. The codebase is a hybrid of a software library and a research project. While the core framework is well-structured with clean abstractions (e.g., Channel, AgentGraph, Recsys), it carries significant research code debt: tight coupling to the fast-moving camel-ai framework, global state in recommendation modules, skipped tests, hardcoded paths in experiments, and mixed sync/async patterns. The extensive YAML-driven experiment configurations and visualization scripts are tightly coupled to specific research questions (misinformation, polarization) and datasets. Maintenance is active in the context of ongoing research, but the codebase shows signs of technical drift (skipped tests, commented-out features, dependency on specific LLM API patterns). It is a powerful tool for researchers but would require significant hardening for production use.
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.
Direktiv is an event-driven serverless orchestration and automation platform. It enables users to define, execute, and monitor workflows using TypeScript or YAML, manage API gateways with a plugin chain (authentication, inbound transformation, target routing, outbound transformation), schedule tasks via cron, handle events (CloudEvents), and orchestrate services on Kubernetes/Knative. The system is designed for integration and automation scenarios, providing a low-code page builder, workflow editor, and comprehensive management UI. The architecture consists of a Go backend (API server, workflow engine, gateway, scheduler, sidecar, telemetry) and a React/TypeScript frontend. Key entry points include the CLI (`cmd/main.go`), REST API (`internal/api/`), workflow runtime (`internal/engine/runtime/`), gateway router (`internal/gateway/`), and cron scheduler (`internal/sched/`). Data flows involve compiling workflows from TypeScript to an internal representation, executing them via a state machine, persisting state in PostgreSQL, and using NATS for cluster-wide messaging and event streaming. External dependencies include PostgreSQL, NATS, Kubernetes/Knative, OpenTelemetry, and various Go and Node.js libraries. The frontend is a modern React SPA using TanStack Router, Radix UI, react-hook-form, Zod, and i18next. It provides editors for workflows, endpoints (OpenAPI), services, pages (block editor), and gateway routes, along with dashboards for instances, events, logs, and monitoring. The UI includes a reusable design system with components like Button, Dialog, Table, and Pagination, all demonstrated in Storybook. The backend uses a custom Go-like language (likely a DSL) for its core modules, which may pose maintenance challenges but enables tight integration with the platform's specific needs.
This is a curated collection of roughly 100 self-contained Claude Code skills (agent plugins). Each skill is a directory containing a SKILL.md trigger definition, CLI scripts in Python, Node, or bash, reference documentation, and frequently unit tests; the Claude Code agent invokes them from natural language. The collection spans meeting transcription and summarization, web and deep research, image and audio generation, Telegram and Gmail integration, reversible PII redaction, TDD scaffolding, iOS and Tauri release engineering, project scaffolding, and personal analytics over an Obsidian vault. It functions as a plugin marketplace: skills install into ~/.claude/skills and are triggered on demand.
This repository is a comprehensive plugin marketplace and reference implementation for legal practice automation using Anthropic's Claude AI. It contains 12 first-party plugins (commercial, corporate, employment, privacy, product, regulatory, AI governance, IP, litigation, legal clinic, law student, and a builder hub) plus one vendor plugin from Thomson Reuters. Each plugin provides a set of 'skills' (prompt-engineered workflows) invoked via slash commands, a cold-start interview to configure the AI to a specific legal professional's role and preferences, and optional scheduled agents. The repo also includes five managed-agent cookbooks demonstrating multi-agent orchestration with tool isolation (read-only subagents, write leaf, orchestrator with no write access). While the vast majority of content is markdown prompt files, the repository also contains reusable Python and shell scripts for deployment, validation, and linting of agent configurations. The system is designed to be deployed on Claude Code or Claude Cowork, with MCP connectors for legal research tools, document management, and other integrations. It emphasizes citation provenance, injection defense, and consequential-action gates for non-lawyer users.
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.
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.
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.
SmartDNS-rs is a high-performance, cross-platform DNS server and CLI resolver written in Rust. It functions as a local DNS proxy, intercepting and routing DNS queries through a sophisticated middleware pipeline. It supports a wide array of upstream protocols (UDP, TCP, DoT, DoQ, DoH, DoH3) and provides advanced features like ad-blocking, domain-based policy routing, fastest-IP selection via multi-protocol ping (ICMP, TCP, HTTP, HTTPS), and comprehensive caching with prefetch and serve-expired logic. The architecture is centered around a modular middleware chain (`src/infra/middleware.rs`) that processes incoming requests through components for caching, CNAME rewriting, dual-stack IP selection, bogus NXDomain filtering, nftset/ipset integration, hosts file parsing, and dnsmasq lease integration. Configuration is handled by a robust parser using nom combinators, supporting a wide array of directives. The server exposes a REST API for runtime management and includes platform-specific service management for systemd, launchd, Windows services, and OpenWrt. Key entry points include the CLI (`src/cli.rs`) with subcommands for running the server, managing services, testing configuration, and resolving domains. The core server loop is in `src/app.rs`, with protocol-specific listeners in `src/server/`. The project demonstrates strong engineering practices with its middleware pattern, abstract service installer, and efficient domain matching data structures, though it carries some technical debt in the form of patched upstream dependencies and a few unimplemented stubs.
KVIrc is a production-grade, cross-platform IRC client built on the Qt framework. It features a custom embedded scripting language called KVS (KVIrc Script) with full support for events, aliases, popups, timers, arrays, hashes, object-orientation, and control flow. The application is modular: a core library (kvilib) provides utilities (strings, containers, config, networking, cryptography), the main app (kvirc) manages connection state, IRC protocol parsing, and UI, while dozens of loadable modules (src/modules/) add DCC file transfers, voice/video, media player integration, encryption, language detection, UPnP, KTorrent interface, and more. The UI is heavily configurable with theming, options dialogs, toolbars, and notifier windows. The codebase shows a high degree of craftsmanship in its plugin system, abstraction layers, and the KVS scripting engine, but also carries significant technical debt from its long history (code dating back to the late 1990s) β including manual memory management, custom container classes, conditional compilation for many optional features, and some deprecated Qt API usage.
not-os is a minimal, embedded-focused Linux distribution built entirely as a Nixpkgs overlay, demonstrating how to construct a bootable OS from scratch (kernel, initrd, squashfs root) using NixOS modules while replacing systemd with runit. The repository provides configurations for x86_64 QEMU, Raspberry Pi (ARM), and Xilinx Zynq targets, along with an iPXE boot chain featuring cryptographic signature verification for secure boot. It illustrates advanced Nix techniques for building custom initrds, integrating firmware, and creating reproducible embedded system images, though some components (like the dummy stage-2 init script placeholder) indicate a focus on flexibility over polish. The codebase is well-structured with clear module boundaries and includes Hydra CI integration for automatic testing.
This is a self-hosted social timeline application (moments/ζεε) that allows users to post short updates (memos) with rich media: images, videos, music, links, and Douban (Chinese media database) book/movie references. The architecture is a single Go binary that embeds a Nuxt.js static frontend and connects to a SQLite database. The backend provides a REST API with JWT authentication, supports file upload (local or S3), comment system with email notifications, RSS feed generation, and database backup on version changes. Noteworthy features include automatic database backup with cleanup, image thumbnail generation, Google reCAPTCHA integration, and a calendar-based search for memos. The codebase is well-organized with dependency injection (samber/do), proper route grouping, and data migration scripts. The frontend is a Nuxt 3 SPA with Tailwind CSS and component-based UI. The project is actively maintained with frequent commits and a responsive issue tracker.
nodemon is a CLI tool and library that monitors a directory for file changes and automatically restarts a specified command (typically a Node.js application). It parses command-line arguments and configuration files (nodemon.json, package.json) to determine watch paths, ignore patterns, file extensions, and the command to execute. It uses chokidar for file system watching and manages child processes via fork or spawn. When changes are detected, it matches the changed files against configured rules and restarts the child process if appropriate. It supports custom signals, delay, legacy polling, and event hooks. The architecture is monolithic with a library API, key modules include CLI parser, config loader, rule engine, file watcher, and process manager. The codebase relies on non-standard Node.js APIs (e.g., process.stdin.setEncoding, child_process.fork, process.versions.node), indicating significant technical drift from standard Node.js, though the tool remains widely used and actively maintained.
This repository provides a file and folder icon theme for Visual Studio Code and VSCodium, using the Catppuccin pastel color palette. The extension includes SVG icons for hundreds of file types, frameworks, and tool-specific configurations, plus folder icons for common directory names. It is implemented as a VS Code extension that dynamically generates themed icon sets based on user preferences (monochrome, specific folders, custom associations). The architecture separates icon definition data (fileIcons.ts, folderIcons.ts) from runtime logic (configuration hooks, theme compilation) and build-time scripts (SVG optimization, flavor generation, preview generation). The code is well-structured TypeScript with functional modules, but the actual executable logic is thinβmost of the repository's value lies in the curated icon associations and design consistency. There are no complex algorithms or reusable libraries; the extension is primarily a configuration-driven asset pipeline with a lightweight VS Code activation handler.
mdui is a comprehensive Web Component library implementing Material Design 3 (Material You). It provides over 30 reusable UI components (buttons, dialogs, navigation, forms, etc.) built with Lit, supporting dynamic color theming, dark/light modes, and localization across 60+ languages. The library is framework-agnostic and can be used directly in HTML or with any frontend framework. It includes a bundled jQuery-like utility (@mdui/jq) for DOM manipulation, a Model Context Protocol (MCP) server for AI-assisted development tooling, and IDE plugins for VS Code and JetBrains. The codebase is well-structured with a monorepo managed by pnpm, featuring shared mixins, controllers, and decorators that promote consistency across components. The project is actively maintained with recent commits, comprehensive documentation, and a large demo site.
This is a monorepo for maptalks.js, a comprehensive browser-based 2D/3D mapping and GIS rendering engine. The system provides interactive web maps with support for vector tiles (MVT), 3D tiles (I3S, Cesium 3D Tiles), GLTF/GLB models, terrain elevation, and spatial analysis (viewshed, cut, flood, skyline). It features a dual rendering backend: a Canvas2D renderer for basic maps and a WebGL/WebGPU renderer with a modular shader system (reshader) supporting PBR materials, lighting, shadows, bloom, fog, rain, and post-processing effects. The architecture is a monorepo with pnpm workspaces and Turbo, containing over 20 packages including core map engine (maptalks), GL rendering framework (gl), vector tile layer (vt), 3D analysis (analysis), traffic simulation (traffic), GLTF loader, 3D tiles layer, and WebGL sandbox (fusion.gl). Key entry points are the Map class, layer classes (VectorTileLayer, Geo3DTilesLayer, GLTFLayer), and analysis tools. Data flows involve fetching tiles/models from remote sources, parsing in workers (Web Workers for tile building, GLTF decoding, terrain processing), and rendering via the shader pipeline. External dependencies include gl-matrix for math, @mapbox/vector-tile for MVT parsing, and various WebGL/WebGPU APIs. The codebase is actively maintained with frequent commits, but shows medium technical drift due to dual shader language maintenance (GLSL + WGSL), some duplicated utility code across packages, and commented-out or deprecated features.
OASIS is a CLI-first security analysis tool written in Python. It orchestrates a multi-phase LangGraph pipeline (Discover β Scan β Expand β Deep β Verify β Report) to detect vulnerabilities in source code using local LLMs via Ollama or OpenAI-compatible servers. The tool supports 25+ vulnerability types across multiple languages, produces deterministic verdicts without LLM reliance, and integrates with CI via severity-gated exit codes, suppression registries, and report diffing. It is installed via pipx or Docker and run as `oasis -i /path --models ...`.
Cyber Engine Tweaks is a modding framework for Cyberpunk 2077 that injects a DLL into the game process to provide a Lua scripting environment, an ImGui-based overlay (console, TweakDB editor, settings, log viewer), and quality-of-life patches (disable vignette, disable boundary teleport, skip start menu). It hooks into D3D12 rendering and input systems, reverse-engineers the game's RTTI layer via RED4ext.SDK, and exposes game objects, functions, and the TweakDB to Lua scripts. Modders can place Lua scripts in a `mods` folder, which are executed in sandboxes with access to the full ImGui widget library (via sol_imgui) and SQLite databases (via lsqlite3). The architecture is monolithicβa single DLL orchestrates all subsystems (core initialization, hooking, scripting, overlay, reverse engineering, patching). External dependencies include LuaJIT, sol2, Dear ImGui, MinHook, spdlog, nlohmann/json, and TiltedPhoques library. The codebase is actively maintained but carries inherent drift risk due to hardcoded game offsets that must be updated per game patch.
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.