TheAlgorithms/Java is a comprehensive, community-maintained collection of over 600 algorithm and data structure implementations in Java, organized into topic-specific packages (e.g., maths, sorts, searches, dynamic programming, graph, ciphers, compression, machine learning, streaming). It is designed as an educational reference library, not a production application. The architecture follows a modular utility-class pattern: most algorithms are implemented as final classes with private constructors and static methods, and many implement shared interfaces such as SortAlgorithm and SearchAlgorithm for polymorphic usage. The codebase includes extensive JUnit 5 test coverage with parameterized tests, and many classes reference Wikipedia or academic sources. While the overall quality is high with many reusable components, there are some inconsistencies such as duplicate implementations, leftover main methods, and occasional use of raw types or legacy APIs. The repository is actively maintained with CI workflows, dependabot, and a structured contribution process.
This repository, ai-hedge-fund, is a production-grade simulation engine for running AI-managed hedge funds in educational and research contexts. It provides a dual-mode system supporting both historical backtesting and live paper trading, all adhering to point-in-time data integrity to prevent look-ahead bias. The architecture is modular and protocol-based, with swappable components for data acquisition (Financial Datasets API), LLM providers (Anthropic, OpenAI, DeepSeek, Google, xAI, Kimi, TypeSafe/Jev), broker execution (simulated/paper), signal generation (quant models and LLM agents emulating investors like Buffett, Munger, Graham), and risk management. The engine includes a hash-chained ledger for tamper-evident record keeping, prompt caching to eliminate redundant LLM costs during backtests, and a textual TUI for interactive management. It is explicitly not intended for real trading and is released under MIT license. The codebase is well-structured with clean abstractions, though it carries some technical debt from being a ground-up v2 rebuild that is not yet fully integrated with its predecessor, and contains hardcoded constants and magic numbers that limit configurability.
free-claude-code is a local proxy and developer tool that connects coding agents (Claude Code and similar harnesses) to OpenAI-compatible AI providers. It is a Python package (`free_claude_code`) with a CLI, a local API server, an admin web UI, and a substantial configuration subsystem. The system abstracts over a dozen AI providers (including NVIDIA NIM, Cloudflare, HuggingFace, and others) with provider-specific workarounds for tool parameter aliasing, thinking templates, and reasoning replay. It persists sessions, messages, and model metadata in SQLite, manages a tree-based conversation model with Telegram platform support, and renders transcripts with segment-based truncation and subagent state management. The repo is a shipped developer tool with installer/update scripts, GitHub issue templates, dependabot config, and a diagnostic `fcc-doctor` command; it is not a research or data project.
This repository is the source for the C++ Core Guidelines, an evolving set of rules for writing modern C++ safely and effectively. The primary artifact is a large Markdown document (CppCoreGuidelines.md) that is rendered to HTML via Jekyll and published to isocpp.github.io. The repo also contains supporting tooling: a Python style checker that lints C++ code snippets embedded in the Markdown, a script that splits Markdown into prose and code blocks for validation, a Hunspell dictionary for spell-checking the document, and Node.js-based remark configuration for Markdown linting. CI is provided through GitHub Actions, with a legacy Travis configuration still present.
Chatbox is a cross-platform desktop AI chat client (Windows/macOS/Linux) built with Electron, React, and TypeScript. It supports 30+ AI providers (OpenAI, Claude, Gemini, DeepSeek, Ollama, etc.) via a unified provider registry and model abstraction layer. The application features agent mode with tool use, sandboxed code execution, MCP server integration, knowledge base RAG, web search, image generation, and a skills marketplace. It uses a hexagonal architecture with ports/adapters in a core package (`@chatbox/core`) that is host-agnostic, and React bindings in `@chatbox/react`. The renderer uses TanStack Router, Zustand/Jotai for state, and Mantine/MUI for UI. The main process handles IPC, OAuth flows, file system sandbox, and analytics. The codebase is large and well-tested (Vitest unit tests, integration tests, contract tests) with a focus on offline-first, local storage, and cross-platform compatibility (desktop, web, mobile via Capacitor). The application is actively maintained with a commercial 'Pro' version that shares code with this open-source Community Edition. Notable engineering patterns include a clean port/adapter separation, in-memory test doubles for all repositories, a session write coordinator that serializes updates and cancels stale queries, a draft tokenization system with web workers, and a provider registry that allows dynamic model discovery. The codebase has some technical debt: multiple UI libraries, legacy migration paths, and commented-out code, but overall demonstrates strong craftsmanship and reusability of its core abstractions.
ColossalAI is a comprehensive distributed training and inference framework for large-scale deep learning models, providing multiple parallelism strategies (data, tensor, pipeline, sequence, mixture-of-experts), ZeRO memory optimization, automatic parallelization via FX tracing, and high-performance custom CUDA/Triton kernels. The architecture is library-based with a plugin-style booster for orchestrating training and inference, a shardformer for model-level parallelism policies, and a legacy subsystem for older APIs. It includes application-level tools: ColossalChat for RLHF (PPO, DPO, GRPO), ColossalQA for retrieval-augmented question answering, ColossalEval for LLM evaluation with GPT judges, and Colossal-LLaMA for domain-specific LLM training. The codebase is actively maintained with recent commits, but has notable technical drift due to outdated dependency pins in some examples and a large legacy namespace that coexists with newer implementations.
This repository is the source code for 'Enjoy App', a cross-platform desktop application built with Electron, React, and TypeScript. Its primary function is English language learning, specifically focusing on pronunciation training, shadowing practice, and AI-assisted conversation. The application integrates local speech-to-text (Whisper/Echogarden) and text-to-speech engines alongside cloud-based LLMs (OpenAI, Azure) for chat and translation features. It employs a local-first architecture using SQLite (Sequelize ORM) for data persistence, with synchronization capabilities to a remote backend for backup and community features. The architecture follows a standard Electron pattern with a Main process handling native features, database operations, and media processing (FFmpeg, Echogarden), and a Renderer process serving the React UI. State management is handled via a combination of React Context Providers and custom Redux-like reducers. The codebase includes extensive AI command handlers for tasks like translation, summarization, and pronunciation assessment. While the application is feature-rich and well-structured, it carries significant coupling in media state management and relies heavily on external API contracts for core functionality.
This repository is a community-driven collection of Linux command documentation in Chinese, presented as a static website. It includes a build system (scripts/build.mjs) that reads Markdown files from the command/ directory, generates a JSON index (dist/data.json), compiles Stylus to CSS, renders EJS templates to HTML, and produces a deployable static site. The project also generates offline documentation in Dash docset format (scripts/dash.mjs) and publishes an npm package (linux-command) containing the command index. The site is deployed to GitHub Pages, Vercel, Netlify, and as a Docker image. The architecture is a static site generator with a client-side search widget, dark mode, and copy-to-clipboard functionality. It is not a traditional application but a documentation platform with a well-structured build pipeline and multiple distribution channels.
UTM is a full-featured virtual machine host for iOS and macOS, built on top of QEMU and Apple's Virtualization.framework. It allows users to run operating systems such as Windows, Linux, and macOS on Apple devices. The application provides a SwiftUI-based interface for creating, configuring, and managing virtual machines, with support for both emulation (QEMU) and native hypervisor (Apple Virtualization) backends. Key features include SPICE-based display and input, USB device passthrough, shared directories, clipboard synchronization, remote access via a custom TLS-secured protocol, and AppleScript automation. The architecture is modular, with separate layers for configuration models (Codable structs), platform-specific UI (iOS/macOS/visionOS), services (VM lifecycle, SPICE I/O, logging), and a remote server/client component. The build system is complex, involving cross-compilation of patched QEMU, SPICE, and dozens of other libraries via shell scripts, and the project supports multiple product variants (standard, SE with threaded interpreter, remote-only).
SillyTavern is a full-stack web application (Node.js/Express backend, jQuery/Webpack frontend) that serves as a highly customizable frontend for interacting with large language models (LLMs) for roleplaying and chat. It supports dozens of AI backends (OpenAI, Anthropic, Kobold, Ollama, vLLM, etc.) via streaming text and chat completions, and provides an extensive plugin/extension system for TTS, translation, image generation, vector search, and more. The application features a sophisticated macro engine (Chevrotain-based CST parser) for dynamic prompt templating, a slash command framework with typed arguments and autocomplete, and a rich UI with themes, backgrounds, character management, and branching chat history. It is designed for power users who want fine-grained control over prompts, model parameters, and UI behavior, and includes multi-user support with authentication, secrets management, and per-user data isolation.
Anoma is an Elixir/OTP implementation of the Anoma protocol - a distributed operating system for intent-centric applications. The codebase implements a full node architecture with multiple supervised engines: Mempool (transaction submission/ordering), Ordering (consensus sequencing), Executor (parallel transaction execution), Storage (Merkelized key-value store with RocksDB/Mnesia), Shard (partitioned KV store with watermark-based concurrency), IntentPool/Solver (intent matching and composition), Logging (event persistence and replay), and Transport (gRPC/IntraNode networking with proxy-based remote node communication). The system uses Nock/Noun as its core computation model (via anoma-lib), with a Cairo backend for shielded/zero-knowledge transactions. Transactions are submitted as jammed Nock nouns, executed in isolated workers, and results flow through an event-driven architecture (event_broker). The node supports distributed operation via gRPC transport with automatic peer discovery and advertisement. Key architectural patterns: CQRS-style engines (casts for mutations, calls for queries), typed event definitions with filters (defevent macro), supervisor hierarchies with dynamic child management, and a replay mechanism that validates persisted state on restart by spinning up a mock node. The codebase follows an "examples over tests" philosophy - extensive executable examples in lib/examples/ serve as both documentation and integration tests.
ScrapeGraphAI is a Python library that extracts structured data from websites and local documents using LLM-driven graph pipelines. Instead of a traditional web scraper with hardcoded selectors, users define extraction through natural-language prompts and optional Pydantic schemas; the library then executes a directed graph of nodes such as fetching, parsing, chunking, and answer generation. The public API is a set of graph classes (SmartScraperGraph, SearchGraph, JSONScraperGraph, CSVScraperGraph, SpeechGraph, ScriptCreatorGraph, etc.) in scrapegraphai/graphs, each composing reusable nodes from scrapegraphai/nodes and running them on a BaseGraph execution engine. It is consumed programmatically in Python and supports many LLM providers (OpenAI, Ollama, Groq, Mistral, Anthropic, DeepSeek, xAI, NVIDIA, MiniMax) and multiple fetching backends (Playwright, Selenium, Chromium, BrowserBase, Scrape.do). The architecture is a lightweight DAG framework: nodes have typed inputs/outputs, can branch conditionally, iterate, merge results, and accumulate cost/token metadata; BaseGraph walks the graph, handles state, and collects execution information. The repository also contains document loaders, model token/cost registries, prompt templates, telemetry, proxy rotation, screenshot-scraping utilities, a GraphBuilder that constructs graphs from natural language, and integrations such as Burr and Indexify. While the README aggressively promotes a commercial hosted API at scrapegraphai.com, the repository itself is a self-contained open-source library with examples and tests. The codebase is generally well structured and modular, with clear separation between graphs, nodes, prompts, helpers, utils, and models. It shows signs of rapid growth: some typos, duplicated test fixtures, hardcoded model pricing tables, a Python version mismatch between pyproject and Dockerfile, and dependency fragility around LangChain and optional browser/OCR packages. These issues are manageable but give the codebase a medium technical drift. Overall it is an active, useful library for LLM-based extraction, and several utilities are good candidates for reuse outside the project.
Graphiti is a Python library and server framework for building temporal knowledge graphs that serve as persistent memory for AI agents. It ingests unstructured text episodes (messages, transcripts, JSON), uses LLMs to extract entities and relationships with bi-temporal validity windows, deduplicates against existing graph data, and provides hybrid search (semantic + BM25 + graph traversal) with configurable reranking. The codebase is structured around a clean driver abstraction (Neo4j, FalkorDB, Kuzu, Neptune) with per-provider operations classes, a prompt library supporting versioning and overrides, and a multi-provider LLM/embedder/cross-encoder client system. It is primarily an application library, though it includes evaluation infrastructure and research-grade deduplication algorithms (MinHash/LSH).
SortableJS is a mature, standalone JavaScript library for creating reorderable drag-and-drop lists and grids. It supports mouse, touch, and pointer events across modern browsers and legacy browsers like IE11 and Edge. The library is designed as a modular system with a core (Sortable class) and optional plugins (AutoScroll, Swap, MultiDrag, OnSpill) that can be mounted selectively. It exports UMD and ESM builds, integrates with major frameworks (React, Vue, Angular) via separate adapter packages, and provides a rich API with options for grouping, animation, handles, filtering, and custom events. The codebase demonstrates a well-thought-out plugin architecture, event dispatching, and animation state management, though some build tooling and browser workarounds show its age.
This is Microsoft's open-source Windows Calculator, the production calculator app shipped on Windows. The repository is a full UWP/XAML application with Standard, Scientific, Programmer, Date, Unit Converter, and Graphing modes. The core is split into `CalcManager` (a native C++ calculation engine implementing arbitrary-precision rational arithmetic via the Ratpack library), `CalcViewModel` (C++/CX view models handling history, memory, copy/paste, unit data, navigation, and state snapshots), `Calculator` (the C#/XAML UI shell), and `GraphControl` (a DirectX-based graphing control). The app is MVVM-structured, heavily localized in 25+ languages, and includes both C++ unit tests and WinAppDriver-based UI tests.
PicoClaw is an ultra-lightweight personal AI agent platform written in Go, engineered to run on hardware as small as $10 RISC-V boards while providing a full-featured chat agent experience. In production it is a daemon (picoclaw) that connects 30+ LLM providers (OpenAI, Anthropic, Gemini, Azure, Bedrock, Claude CLI, Codex, Ollama, etc. behind a common provider factory) to 19+ messaging channels (Telegram, Discord, WhatsApp, WeChat, WeCom, Slack, IRC, Matrix, DingTalk, Feishu, MQTT, etc.), exposing an agent loop with tool calls, MCP server integration, session management, voice I/O (ASR/TTS), cron jobs, skills marketplace, and hardware tools (I2C, SPI, serial). A companion launcher binary (picoclaw-launcher) runs a Go web backend with an embedded React/TypeScript frontend for configuration, model/channel/credential management, logs, and live chat.\n\nThe architecture is a modular monolith: pkg/agent implements the turn pipeline (context assembly, thinking levels, tool loop, streaming, stop handling), pkg/providers abstracts LLM backends with rate limiting, cooldown tracking, and fallback chains driven by an error classifier, pkg/channels provides a factory-registered channel abstraction over a shared base, and pkg/bus + pkg/events carry inbound/outbound messages and typed runtime events with backpressure. Agents are defined by AGENT.md/SOUL.md workspace files and support delegation/spawning. An experimental evolution subsystem clusters learning records and generates skill drafts via LLM, and the seahorse SQLite FTS5 store provides compacted short-term memory with BM25 retrieval and summary trees. Legacy OpenClaw configs can be migrated.\n\nThe codebase is heavily tested (500+ test files across nearly every package), uses cross-platform build tags for Windows/Linux/Unix/Android, and ships Docker images plus a self-update mechanism. Strong engineering practices include atomic file writes, zip-slip and SSRF protection utilities, typed event buses, factory registries, and a ToolResult structure separating LLM-facing vs user-facing output. The project is pre-1.0 with rapid release cadence; the evolution subsystem, some platform-specific hardware stubs, and the large channel/provider surface are the least mature areas. It is not a data-research repository - the LOCOMO memory benchmark and LLM-as-judge evaluation code in cmd/membench support engineering measurement rather than producing research artifacts.
This repository is a collection of 100+ Python programming exercises with solutions, organized by difficulty level (Beginner/Level 1, Intermediate/Level 2, Advanced/Level 3). Each exercise includes a question, hints, and a solution. While not a production application, it contains numerous self-contained code snippets that demonstrate practical Python programming concepts and patterns. The exercises cover fundamentals like loops and conditionals, data structures, object-oriented programming, file operations, and advanced topics like generators, decorators, and standard library modules. The primary value lies in its reusable code examples that illustrate specific programming techniques.
Maple Mono is an open-source monospace programming font with an extensive build system. The repository is primarily a font engineering toolchain: it takes Glyphs source files, generates variable and static TTF/OTF/WOFF2 fonts, auto-hints them, patches in Nerd Font icons, merges Chinese/Japanese base fonts, and produces dozens of variants (hinted/unhinted, ligature/no-ligature, narrow/slim, etc.). The build is orchestrated by Python scripts (`build.py`, `task.py`) and supports customization via CLI flags or a `config.json` file. A web playground service (`in_browser.py`) allows users to build custom fonts in-browser with selected OpenType features. The codebase is not a running service but a build toolchain with a strong focus on OpenType feature engineering—featuring a custom AST-based DSL for programmatically generating ligature, character variant, and stylistic set feature files. The repository is well-maintained with active GitHub Actions workflows, though the v7 branch is explicitly a frozen snapshot of the current stable release (development continues on the `variable` branch).
Cloudreve is a production-grade, self-hosted file management system (v4) built with Go, Gin, and the ent ORM. It provides a full-featured cloud storage platform supporting multiple storage backends (local, S3, Aliyun OSS, Tencent COS, Huawei OBS, Qiniu, Upyun, OneDrive), WebDAV, WOPI for online Office editing, OAuth2, WebAuthn passkeys, full-text search via Meilisearch, thumbnail generation (vips, ffmpeg, LibreOffice), media metadata extraction (EXIF, ffprobe), and a background task queue for async operations like archive creation, remote downloads, and indexing. The architecture follows a layered pattern with dependency injection, a database-backed filesystem (DBFS) with navigators, an event hub for real-time file events, and a master-slave cluster for distributed nodes. The codebase is well-organized into reusable packages (e.g., pkg/request, pkg/queue, pkg/cache, pkg/auth) and includes a comprehensive admin panel for managing users, groups, storage policies, tasks, and nodes. While primarily an application, it also incorporates data engineering patterns like media metadata extraction and full-text indexing for user-facing features.
Slick is a mature, feature-rich jQuery carousel library that enables developers to create responsive, touch-enabled sliders with minimal configuration. The core implementation in slick/slick.js provides a comprehensive set of options (over 50 settings), events, and methods for controlling slide behavior, including infinite looping, center mode, variable width, vertical orientation, lazy loading, and responsive breakpoints. The library emphasizes accessibility with ARIA attributes, keyboard navigation, and focus management. The code is well-structured as a jQuery plugin with AMD/CommonJS module support, and includes fallback mechanisms for CSS transitions and transforms. The accompanying SCSS/LESS stylesheets offer customizable theming through variables. While the library is tightly coupled to jQuery, it remains a robust and widely-used solution for building carousels in jQuery-based projects.