This repository is an opinionated Angular style guide by John Papa, primarily targeting AngularJS (1.x). It is not a runnable application but a comprehensive documentation resource prescribing coding conventions, architecture patterns (LIFT, modularity, folder-by-feature), and best practices for building Angular 1 applications. The repo contains the full guide in English and 12+ community-translated versions, along with editor snippets for various IDEs. While no executable code exists, the guide itself serves as a reference for legacy Angular projects and continues to receive maintenance (last commit 2026-04-30). The companion guide for Angular 2+ is largely a stub pointing to official documentation.
TRELLIS.2 is a research codebase for state-of-the-art image-to-3D generation using a novel sparse voxel representation (O-Voxel) and flow matching with 4B parameters. It provides full training and inference pipelines for generating high-fidelity 3D meshes with PBR materials from single images. The repository includes custom CUDA extensions for voxel processing, a flexible sparse tensor library, and comprehensive dataset tooling for large-scale 3D asset curation (Objaverse-XL, Sketchfab). While primarily a research project with training code and data pipelines, it also offers Gradio web demos and Python APIs for inference. The codebase demonstrates strong engineering in its modular design (pipelines, mixins, config-driven training) but suffers from some research-typical issues like code duplication, hardcoded paths, and fragile dependency management.
IPQuality is a comprehensive bash-based CLI tool for evaluating the quality and risk profile of an IP address. It performs geolocation lookups (via Maxmind and IPinfo), IP type classification (ISP, hosting, business, etc.), risk scoring from multiple threat intelligence providers (AbuseIPDB, IP2Location, IPQS, Scamalytics, etc.), streaming media unlock detection (TikTok, Disney+, Netflix, YouTube, Amazon Prime Video, Reddit, ChatGPT), email service connectivity tests (Gmail, Outlook, Yahoo, etc.), and DNS blacklist checks against 400+ databases. The script is designed for VPS owners and network administrators to quickly assess whether an IP is clean, blocked, or associated with proxies/VPNs. It supports dual-stack IPv4/IPv6, multiple operating systems, Docker, and various output formats (ANSI, JSON, plain text). The architecture is a single monolithic bash script (~78000 tokens) with modular functions, progress bars, and extensive error handling. While not a reusable library, it demonstrates advanced bash scripting patterns for network diagnostics.
DeepEP is a high-performance communication library developed by DeepSeek for distributed Mixture-of-Experts (MoE) model training and inference. Its primary function is implementing expert-parallel (EP) all-to-all dispatch and combine operations, routing tokens to the correct GPU holding an expert and gathering the results. It also provides general collective communication primitives (all-reduce, reduce-scatter, all-gather) optimized for multi-node multi-GPU clusters with NVLink and RDMA interconnects. The architecture is a hybrid Python/C++/CUDA library. The Python layer (deep_ep) provides user-facing buffer classes (EPBuffer, BucketBuffer, EngramBuffer, PPBuffer) and orchestration utilities. The C++/CUDA layer (csrc/, deep_ep/include/) contains JIT-compiled kernels that leverage cutting-edge NVIDIA Hopper/Blackwell features (TMA, mbarriers, NCCL GIN) for maximum performance. The library is designed to overlap communication with computation through deferred epilogue patterns. The codebase exhibits exceptional craftsmanship in its low-level CUDA kernels, particularly the ptx.cuh utility layer and the distributed barrier implementations. The Python utilities (EventOverlap, weak_lru, EnvOverride, BufferAllocator) are well-isolated, elegant patterns that are genuinely reusable in other GPU or distributed computing projects. However, the library has a high technical drift risk due to its deep reliance on experimental and rapidly evolving NVIDIA APIs (NCCL device-side, specific CUDA architecture features). It is tightly coupled to a specific hardware stack (Hopper+ GPUs, NVLink, RDMA) and software versions (CUDA 13.1+, NCCL 2.32.3+). While actively maintained, its specialized nature and complex build system limit its applicability outside of large-scale MoE training on cutting-edge NVIDIA clusters.
This repository contains the GitHub Copilot Chat extension for Visual Studio Code. It provides an AI-powered coding assistant with multiple interaction modes: inline code completions (ghost text), chat conversations, inline edits, next-edit suggestions, and agent-based tool orchestration. The extension supports multiple AI model providers (OpenAI, Anthropic, Google Gemini, xAI, and bring-your-own-key endpoints) and includes a sophisticated prompt engineering system using JSX-based prompt elements. It integrates deeply with VS Code through dozens of proposed APIs, and features a layered architecture (common/node/vscode) with dependency injection, telemetry, and a simulation test framework. While the README states the project has moved to the main VS Code repository, the codebase shows active development with recent commits and extensive feature work.
Evolution API is a production-grade, multi-tenant WhatsApp API gateway built with Node.js, TypeScript, and Express. It manages independent WhatsApp instances via Baileys (WhatsApp Web), Meta Business API, and its own Evolution API channel, providing REST endpoints for messaging, chat management, groups, labels, and media. The system integrates deeply with chatbot platforms (Typebot, OpenAI, Dify, Flowise, N8N, EvoAI, EvolutionBot) and event systems (Webhook, WebSocket, RabbitMQ, SQS, NATS, Kafka, Pusher), and includes storage via S3/MinIO and CRM sync with Chatwoot. The architecture follows a modular controller-service pattern with Prisma ORM (supporting MySQL and PostgreSQL), Redis caching, and centralized configuration. It is actively maintained with frequent updates, extensive migrations, and CI/CD pipelines.
Xinference is a production-grade model serving platform that provides OpenAI-compatible REST APIs for a wide range of AI models including LLMs, embeddings, rerank, image generation, video, audio/TTS, and world models. It supports multiple inference backends (vLLM, SGLang, transformers, MLX, llama.cpp) and can be deployed as a single process or a distributed cluster using an actor-based supervisor/worker architecture (xoscar). The system includes a web UI for model management, authentication/authorization with OAuth2 scopes, token-aware routing for load balancing, and monitoring capabilities. It bundles many third-party model implementations for turnkey deployment, which reduces setup friction but introduces maintenance overhead from vendored code. The architecture is a hybrid of a monolithic FastAPI server and a distributed actor system. Key entry points are CLI commands (xinference, xinference-supervisor, xinference-worker) and the REST API. The frontend is a Next.js application statically exported and served by the backend. The codebase demonstrates strong patterns in modular route registration, plugin-style model registries, and streaming response handling, but also carries significant technical debt from heavy vendoring, duplicated code across third-party integrations, and version-sensitive patches to upstream libraries like vLLM.
pgweb is a web-based PostgreSQL database explorer written in Go. It provides a single-page application frontend (jQuery, Bootstrap 3, Ace editor) and a REST API backend (Gin framework) for browsing schemas, executing SQL queries, viewing table data, and exporting results. The application supports multi-session management, SSH tunnels, TOML-based bookmarks, Prometheus metrics, and third-party authentication backends. It is distributed as a single cross-platform binary with zero external runtime dependencies beyond a PostgreSQL server. The architecture is a monolith: the Go server serves static files and exposes API endpoints for database operations. Key entry points are the CLI (main.go -> pkg/cli/cli.go) and the API routes (pkg/api/routes.go). The codebase demonstrates solid engineering with clean abstractions for database client, connection string building, session management, and metrics, but the frontend relies on outdated libraries (jQuery 2.1.1, Bootstrap 3, Ace editor) and the project shows some technical drift in dependency versions and deprecated environment variables.
Cloudflare's CFSSL is a comprehensive PKI/TLS toolkit written in Go, providing both a command-line interface and an HTTP API server for certificate lifecycle management. It handles certificate signing, chain bundling, revocation (CRL/OCSP), TLS scanning, key generation, CSR creation, and CA initialization. The system is modular, with separate packages for CLI commands, API handlers, signers (local/remote), certificate database abstraction (SQLite/MySQL/PostgreSQL), a bundler with chain optimization, an OCSP responder, a TLS scanner, and a transport layer for automated mutual TLS. It uses interface-based design for pluggable backends (signers, database accessors, key providers, trust stores) and includes features like multi-root CA support, pre-issuance linting via zlint, certificate transparency embedding, ubiquity scoring for chain selection, IP whitelisting, HMAC authentication, Prometheus metrics, and post-quantum cryptography (ML-DSA). The codebase also contains custom cryptographic implementations (MD5, SHA-1, SHA-256, SHA-512) with assembly-optimized blocks for performance. While actively maintained with CI/CD and extensive tests, some components show technical drift (pinned Go 1.27, forked TLS library, legacy algorithm support).
Gobot is a Go framework for robotics, physical computing, and the Internet of Things. It provides a consistent hardware abstraction layer (HAL) over dozens of single-board computers (Raspberry Pi, BeagleBone, Intel Edison, Jetson, etc.), microcontrollers (Arduino via Firmata, Digispark), and communication protocols (GPIO, I2C, SPI, BLE, serial, MQTT, NATS, MAVLink). The architecture is modular: platform-specific adaptors implement core interfaces (DigitalPinner, PWMPinner, I2cBusAdaptor, etc.) and are composed from reusable building blocks in the `platforms/adaptors` package. Drivers for sensors, actuators, displays, and robots (Sphero, Parrot drones, DJI Tello, GoPiGo3) are organized by bus type (gpio, i2c, spi, ble, aio, onewire, serial) and share a common lifecycle pattern with event publishing and command registration. A built-in HTTP API server (with optional basic auth and CORS) exposes robot state and commands over REST and Server-Sent Events, and includes an embedded web UI (Robeaux). The framework supports both high-level orchestration via `Robot` and `Manager` and low-level 'metal' usage for direct hardware control. External dependencies include `periph.io` for GPIO, `tinygo.org/x/bluetooth` for BLE, `gocv.io/x/gocv` for computer vision, and `go.bug.st/serial` for serial communication. The codebase is extensively tested with mock filesystem and syscall infrastructure, and uses functional options for configuration throughout.
Vitesse is an opinionated Vue 3 + Vite starter template created by Anthony Fu. It provides a pre-configured development environment with file-based routing, auto-importing of components and APIs, state management via Pinia, internationalization (i18n) with lazy-loaded locale files, PWA support, Markdown-as-Vue-components, and utility-first CSS via UnoCSS. The template uses static site generation (SSG) via vite-ssg and includes critical CSS extraction. It is designed to accelerate the setup of modern Vue applications by integrating a curated set of plugins and tools. The codebase is well-structured, with clear separation of concerns: pages, layouts, composables, stores, and modules. The i18n module demonstrates a reusable pattern for lazy-loading translations using Vite's glob imports. While the template is primarily a collection of configurations and boilerplate, it exhibits high craftsmanship in its integration choices and adherence to Vue 3 best practices.
Unicorn Engine is a lightweight, multi-architecture CPU emulation framework derived from QEMU. It provides a pure C API with bindings for Python, Go, Java, Rust, Ruby, .NET, Haskell, Pascal, Zig, and VB6. The engine supports ARM, ARM64, M68K, MIPS, PowerPC, RISC-V, S390X, SPARC, TriCore, and x86 (16/32/64-bit). It is used primarily for security research, reverse engineering, fuzzing, and dynamic analysis of binary code. The architecture is a library with a central C API that exposes memory mapping, register access, hooks (code, block, memory, interrupt, instruction, syscall, TLB), and context save/restore. The core emulation logic is based on QEMU's TCG (Tiny Code Generator) for dynamic binary translation, with a custom glib compatibility layer to eliminate external dependencies. The repository includes extensive regression tests, fuzz targets, and sample programs for each architecture and binding. While the engine is actively maintained and widely used, it carries technical debt from its QEMU fork (based on QEMU 5.0.1) and auto-generated binding constants that may drift from the C API.
PPTist is a full-featured web-based slide editor and presentation application, built with Vue 3, TypeScript, and Pinia. It replicates core PowerPoint functionality entirely in the browser, supporting text, image, shape, line, chart, table, video, audio, and LaTeX elements. Users can create, edit, animate, and present slides, with import/export support for PPTX, PDF, images, and a custom .pptist format. An AI-assisted slide generation feature allows users to input a topic and receive a complete slide deck via an external API, with template-based layout and image selection. The architecture is a single-page application with a custom canvas rendering system, rich text editing via ProseMirror, and state management through Pinia stores. The editor is divided into three main modes: Editor (full editing with thumbnails, toolbar, and canvas), Screen (presentation with speaker notes, audience view, writing board, and laser pointer), and Mobile (basic editing and preview for touch devices). Data persistence uses IndexedDB via Dexie for undo/redo snapshots, and slide data is stored as JSON in Pinia stores. External dependencies include ECharts for charts, pptxgenjs for PPTX export, and a backend server for AI generation and image search. Key entry points include src/App.vue (top-level routing), src/views/Editor/index.vue (main editor), src/views/Screen/index.vue (presentation mode), and src/views/Mobile/index.vue (mobile mode). Data flows center on the slide store: user actions trigger mutations captured as snapshots for undo/redo, export processes convert internal JSON to target formats, and import parses external files into the internal schema. The AI PPT flow sends a user prompt to the backend, receives an outline and slide data, then fills template slides with content and images. The application is actively maintained with a large community (9386 stars, 1770 forks) and is licensed under AGPL-3.0. It relies on an external backend for AI features and image search, meaning those features are not self-contained. The codebase is well-structured but lacks automated tests, and some components (e.g., HTML parser, shape library) are self-contained and potentially reusable in other projects.
RSS-Bridge is a PHP web application that generates RSS, Atom, and JSON feeds for websites that do not natively provide them. The core architecture is a plugin framework: each of the 447 'bridges' in bridges/ extends BridgeAbstract (or FeedExpander/XPathAbstract/CssSelectorBridge) and implements collectData() to scrape HTML, consume JSON APIs, parse embedded JSON-LD/Next.js state, or expand existing feeds into a standardized item structure. A front controller (index.php) dispatches through a middleware pipeline (security, caching, basic/token auth, exception handling) to actions such as DisplayAction, FrontpageAction, ListAction, and FindfeedAction, then renders items via pluggable output formats (Atom, MRSS, JSON Feed, HTML, Plaintext, Sfeed). Both web and CLI request paths are supported, and the Docker deployment is production-ready with nginx + PHP-FPM and curl-impersonate for anti-bot evasion. The framework itself demonstrates solid engineering: a lightweight DI container, factory classes for bridge/format/cache discovery, a well-designed HTTP client layer with retry logic and CloudFlare detection, a standalone RSS 1.0/2.0/Atom/MediaRSS feed parser, systematic SEO/JSON-LD metadata extraction, and multiple cache backends (file, SQLite WAL, memcached, null) with TTL policies. PHPUnit tests cover feed parsing, format output snapshots, cache implementations, parameter validation, and BridgeImplementationTest enforces structural conventions across all bridges. The bridge base-class conventions (PARAMETERS arrays, contexts, detectParameters, throwClientException/throwServerException) are consistent and well-documented. The dominant weakness is inherent to the scraping domain: most bridges rely on brittle CSS selectors, undocumented APIs, or hardcoded endpoints that break as upstream sites change. Known issues visible in code include hardcoded API keys (Formula1, Giphy, Instructables, TwitterClient), deprecated/duplicate bridges (VkBridge states 'Does not work anymore'; Mozilla and Kernel BugTracker bridges defer to BugzillaBridge), logic bugs (Modrinth parameter key typo, GGDeals assignment-in-condition, Steam assignment-in-condition), a PHP 7.4 compatibility floor (EOL since 2022), and bundled Parsedown 1.7.4. The anti-bot arms race adds ongoing maintenance burden, and many low-traffic bridges appear effectively unmaintained. Overall, the core framework is a strong, extensible example of plugin-style feed generation architecture with genuinely reusable components; the bridge corpus is heterogeneous in quality, mixing well-crafted adapters with fragile scrapers. The project is actively maintained with recent commits, CI workflows, and a large contributor base.
BetterDiscord is a client modification for Discord that injects into the Electron app to provide a plugin and theme system, custom CSS editor, addon store, updater, and developer tools. The architecture is a monolith within the Discord client, structured as three packages: injector (main process), preload, and renderer. Key entry points include the main process (`src/electron/main/index.ts`), preload script (`src/electron/preload/index.ts`), and renderer initialization (`src/betterdiscord/index.ts`). Data flows involve IPC between main and renderer, webpack module interception for patching Discord's React components, file system access for addons and settings, and GitHub API for updates. External dependencies include Electron, React, Monaco Editor, lucide-react, and react-spring. The codebase is well-structured with TypeScript, has tests, and exposes a comprehensive API (`BdApi`) for plugin developers. However, it heavily relies on Discord's internal webpack modules and hardcoded module IDs, making it brittle and requiring frequent updates as Discord changes. The project is actively maintained with recent commits and responsive issue triage.
PraisonAI is a production-oriented, multi-language AI agent orchestration framework shipped as a monorepo of cooperating Python, TypeScript, and Rust packages. The core SDK (`praisonaiagents`) implements `Agent`, `Task`, `AgentTeam`, and `AgentFlow`/`Workflow` abstractions with MCP support (stdio/HTTP/WebSocket/SSE), integration with 20+ LLM providers via LiteLLM-style configuration, memory backends (SQLite, file, mem0, MongoDB), RAG/knowledge bases over vector stores, guardrails, approval flows, policy engines, context compaction, telemetry, background jobs, and durable run ledgers. A user-facing `praisonai` wrapper provides a Typer CLI (`run`, `chat`, `code`, `serve mcp`, agent-as-API), bot adapters for Telegram/Discord/Slack via a WebSocket gateway, sandboxed compute (Docker, E2B, Modal, Daytona), deployment registries, cloud managed agents, and a fine-tuning package (`praisonai-train`). The repository is decisively an application/framework, though it carries data-research features as part of the product surface (RAG pipelines, evaluation loops, synthetic-data generation, LoRA fine-tuning), making it a hybrid in feature terms only.
This repository is a large curated dataset rather than a software application or data pipeline. It contains a multilingual, awesome-list style directory of 3,527 generative AI applications organized into 80 categories, with README.md as the canonical content store. Each entry follows a reproducible markdown record schema: application name, screenshot URL, short description, visit redirect link, and a separate pricing/information link. Categories span the generative AI ecosystem, including AI agents, chatbots, image/video generation, code assistants, legal, accounting, and gaming. The data_research classification reflects the fact that the primary asset is structured content, not executable code; there are no notebooks, model files, or ETL scripts in the repository.
Local Deep Research is a self-hosted, privacy-focused AI research assistant that performs deep, agentic research using multiple LLMs and web searches. It provides a full-stack web application (FastAPI + JavaScript), a programmatic API, and a Model Context Protocol (MCP) server. The system ingests user queries, decomposes them, executes parallel searches across web and academic sources (SearXNG, Google, arXiv, PubMed, Semantic Scholar, etc.), fetches and extracts content, evaluates evidence, and synthesizes reports with citations. It features per-user encrypted SQLCipher databases, a settings system with environment variable overrides, a RAG library with FAISS vector store, journal quality scoring, news subscriptions, and extensive security controls (egress policy, SSRF protection, credential scrubbing). The codebase is heavily tested with unit, integration, UI, accessibility, and security tests. It is a hybrid of a web application and a research data pipeline, but the dominant character is a production-grade application.
Dolphin is a document image parsing tool that uses a two-stage analyze-then-parse approach with a VLM (Qwen2.5-VL). It takes images or PDFs, performs layout analysis to detect elements (text, tables, formulas, code, figures) with reading order, then parses each element in parallel batches. Outputs structured JSON and Markdown with visualized layout. The codebase is well-structured, offering CLI entry points for page-level, element-level, and layout-only parsing. It demonstrates good engineering practices with batching, coordinate mapping, and post-processing for formula/special characters. The core implementation wraps the Hugging Face Qwen2.5-VL model and includes utility modules for layout string parsing, PDF conversion, and markdown generation. The architecture is a CLI application with minimal coupling, making the utility modules potentially reusable across document parsing projects.
FLARE-VM is a collection of PowerShell and Python scripts for automating the setup of a Windows-based reverse engineering virtual machine. The core installer (`install.ps1`) uses Chocolatey and Boxstarter to deploy a curated set of malware analysis tools, configure environment variables, registry settings, and taskbar layout. It provides both a GUI and CLI mode for package selection. The repository also includes a set of VirtualBox helper scripts (`virtualbox/`) for building, exporting, and cleaning VM snapshots, as well as monitoring network adapter status. These scripts are well-structured and can be reused independently for VirtualBox automation. The project is actively maintained by Mandiant (Google) and serves the malware analysis community.