This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.
CloudMeet is a full-stack meeting scheduler (Calendly alternative) built entirely on Cloudflare's free tier. It uses SvelteKit for the frontend and server-side logic, Cloudflare D1 for the database, KV for caching, and Workers for cron-based email reminders. The application supports single-user (admin) operation with Google Calendar and Outlook Calendar integration, allowing attendees to book meetings that automatically create calendar events with video conferencing links (Google Meet or Microsoft Teams). It includes a comprehensive email notification system via Emailit API, customizable availability rules, event types, and a dashboard for managing bookings, profiles, and email templates. The architecture is a monolith deployed to Cloudflare Pages with a separate cron worker for reminders. The codebase demonstrates solid engineering practices: TypeScript throughout, well-structured caching layer with KV and browser cache, request coalescing, input validation, and a modular email template system. It is not a data research project; it is a production-ready application.
Litube is a full-featured Android YouTube client that replaces the official app with an ad-free, customizable experience. It wraps YouTube's mobile site in a WebView and injects JavaScript to remove ads, restore dislikes, add download buttons, and control playback. A native player (Media3 ExoPlayer) handles video/audio playback with support for quality selection, subtitles, audio tracks, PiP, background audio, and Chromecast casting via a custom CastV2 protocol implementation. A robust download manager allows offline video and audio with resume, batch operations, and MediaStore integration. The app includes a SponsorBlock client for skipping sponsored segments, an extension system for toggling features (e.g., hide shorts, H264ify), and a comprehensive diagnostic framework for logging and debugging. The architecture is modular: clean separation between extraction (NewPipe fork), playback engine, download pipeline, browser UI, and cast protocol. Heavily tested with both unit and instrumentation tests. The codebase demonstrates strong engineering practices (dependency injection, state machines, pure functions, ring buffers, layered caching) but is tightly coupled to YouTube's non-public APIs and DOM structure, which introduces fragility and maintenance overhead.
Weft is a full-stack, AI-powered personal task management application built with React and Cloudflare Workers. It provides a Kanban-style board where users create tasks that can be executed by AI agents (Claude) using the Model Context Protocol (MCP) to interact with external services like Gmail, Google Docs, Google Sheets, and GitHub. The system features a sophisticated approval workflow: sensitive tool calls (e.g., sending email, creating PRs) require human approval with specialized UI components for reviewing diffs, documents, and spreadsheets. It supports scheduled task execution, real-time WebSocket updates, OAuth-based integrations, and a command palette for keyboard-driven navigation. The architecture leverages Cloudflare Durable Objects for stateful board management, Workflows for long-running agent execution, and a sandboxed environment for running untrusted code. The frontend is a single-page React application with a custom design system, while the backend is entirely serverless on Cloudflare's edge network.
Everest is the primary mod loader and modding framework for the game Celeste. It is a standalone platform rather than a simple script loader: the MiniInstaller patches the game's .NET assemblies at install time using MonoMod, manages native libraries across Windows/Linux/macOS, and provides a full mod SDK. The core project is Celeste.Mod.mm, which contains MonoModRules (build-time patching logic), the Everest runtime (mod loading, dependency resolution, event dispatch), the Everest.Content asset pipeline (crawl/process/apply for textures, maps, dialog), and the Everest.Updater self-update system. Mods interact with the game through a clean event-based hook API (Everest.Events) and registries (e.g., StrawberryRegistry) rather than direct assembly patching. The repository is purely an application/framework; there is no data science, ML, or analytics content. The only data-like artifacts are TAS replay files used for CI validation, not for model training or analysis.
This repository provides a Home Assistant custom component (solax_modbus) that integrates solar inverters from multiple brands (SolaX, Growatt, Sofar, Solis, SRNE, etc.) via Modbus TCP/serial/RTU. It exposes real-time sensor data, battery status, energy totals, and control entities (numbers, selects, switches, buttons, time) into Home Assistant. The component features a plugin architecture where each inverter brand has its own module defining entity descriptions, register maps, and inverter detection logic. It includes an energy dashboard virtual device that aggregates grid, solar, battery, and home consumption for the native Home Assistant Energy Dashboard. Advanced capabilities include remote power control (VPP modes), autorepeat loops, parallel master-slave support, and automatic bad-register quarantine. The codebase is well-tested with unit tests and CI/CD, but suffers from some duplication across plugins and hardcoded register maps.
This repository provides a composite GitHub Action (`actions/upload-pages-artifact`) that packages static website files into a tar archive and uploads it as a workflow artifact for subsequent deployment to GitHub Pages. The action is designed to be used in a build job, producing an artifact that the `actions/deploy-pages` action can later deploy. It handles cross-platform nuances by using GNU tar on macOS (via `gtar`) and `--force-local` on Windows, ensuring consistent archive creation across all hosted runners. The architecture is straightforward: a composite action with three OS-specific archive steps (Linux, macOS, Windows) followed by a single upload step using `actions/upload-artifact`. Inputs include the source directory path, artifact name, retention days, and a flag to include hidden files. The action dereferences symbolic links, excludes `.git` and `.github` directories, and optionally excludes hidden files (those starting with a dot). The output is the uploaded artifact ID. Key implementation details include careful handling of tar flags (`--dereference --hard-dereference`), conditional exclusion patterns, and environment-specific commands. The action is well-documented with clear input/output contracts and is actively maintained with recent commits, automated dependency updates via Dependabot, and a release workflow that publishes major version tags. The codebase is small but robust, focusing on a single, well-defined responsibility with attention to edge cases across operating systems.
The official Terraform provider for Grafana, managing the full lifecycle of Grafana resources across OSS, Enterprise, Cloud, and a wide array of SaaS products (OnCall, Synthetic Monitoring, Machine Learning, k6, Fleet Management, Asserts, Assistant, Incident, App Platform, etc.). The provider employs a mux architecture that combines HashiCorp's Plugin SDK v2 and Plugin Framework, gradually migrating toward the latter. It features a shared client abstraction holding ~20 API clients, a composable resource ID system with typed fields, robust HTTP retry logic with budget control, and extensive acceptance tests gated by environment flags. An experimental code generation tool can import existing Grafana resources into Terraform config, and a generic Kubernetes-style resource supports Grafana's App Platform CRDs. The codebase is actively maintained with a large community, though its vast surface area introduces some technical drift risk from dual-SDK patterns, deprecated fields, and version-dependent features. It demonstrates strong engineering practices with reusable abstractions for resource registration, client injection, and plan modifiers, making it a solid example of a complex multi-API Terraform provider.
This repository implements a full PyTorch backend for Moore Threads MUSA GPUs, providing a drop-in replacement for `torch.cuda`. It enables PyTorch models to run on MUSA hardware with minimal code changes by registering a `PrivateUse1` device backend. The architecture consists of C++ ATen operator implementations (over 200 ops), wrappers around the proprietary muDNN deep neural network library, a core runtime layer (streams, events, caching allocator, IPC), distributed training via MCCL (MUSA Collective Communications Library), an Inductor compiler backend with Triton support, quantization (W4A16, int8), and profiling tools. Key entry points include `torch_musa/__init__.py` for autoload, `setup.py` for building, `torch_musa/csrc/core/MUSAHooksInterface.cpp` for device registration, and `torch_musa/csrc/aten/ops/` for operator implementations. Data flows follow PyTorch's dispatch mechanism: operations are routed to MUSA-specific kernels via the `PrivateUse1` dispatch key, with muDNN handling most deep learning primitives. External dependencies include PyTorch (patched for version 2.11.0), muDNN, MCCL, musolver, muFFT, and Triton. The repository also includes automated CUDA-to-MUSA porting tools (`tools/cuda_porting/`) and a comprehensive test suite covering operators, distributed training, quantization, and sparse tensors.
This repository provides a cross-platform C++ tokenizer binding library that wraps HuggingFace tokenizers (via Rust), SentencePiece, and a custom RWKV world tokenizer. It exposes a common abstract interface (`Tokenizer`) with factory methods to create instances from in-memory blobs (JSON, SentencePiece model, BPE vocab/merges, RWKV model). The architecture is a static library with a C FFI layer (`tokenizers_c.h`) and a C++ wrapper (`tokenizers_cpp.h`). The Rust component (`rust/src/lib.rs`) implements the C bindings for the HuggingFace tokenizers crate, while the C++ source files (`src/`) provide implementations for SentencePiece and RWKV. The project also includes a JavaScript/WebAssembly binding via Emscripten (`web/`). Key entry points are the factory functions in `tokenizers_cpp.h` and the `example/example.cc` demonstrating usage. External dependencies include the `tokenizers` Rust crate (v0.21.2), `sentencepiece`, `msgpack-c`, and for the web build, Emscripten. The codebase is well-structured, with clean abstractions and support for multiple platforms (iOS, Android, Windows, Linux, Web).
LongCat-Flash-Omni is an application providing inference capabilities for a 560B parameter omni-modal model that processes text, audio, image, and video inputs to generate text and/or audio outputs. The system features a modular architecture with separate modality encoders (audio, vision), a unified data processor for multimodal inputs, and a post-processor for converting model outputs to usable formats. The main entry point is longcat_omni_demo.py which orchestrates the inference pipeline, leveraging SGLang for efficient model serving. The repository demonstrates strong engineering practices in its modular design, particularly in the audio feature processing and image transformation components.
This repository implements an end-to-end encrypted file transfer system called e2ecp. It consists of a Go-based relay server, a CLI client, and a React web frontend. The system allows users to transfer files or text between peers with zero-knowledge encryption: the relay server never sees plaintext data or metadata. It also supports user accounts with encrypted cloud storage, file sharing via links, device authentication, and email verification. The architecture is a monolith with a WebSocket relay, HTTP API, PostgreSQL database, and separate client implementations. Key entry points are the CLI (main.go), the relay server (src/relay/relay.go), and the React app (web/src/App.jsx). The codebase is well-structured with comprehensive testing, CI/CD, and Docker support. However, there are some maintenance risks such as duplicated protobuf schemas between Go and JavaScript, and the use of a future Go version (1.25) in go.mod, which may indicate dependency drift.
This is the Dogtag PKI (Red Hat Certificate System) codebase, a comprehensive enterprise-grade Public Key Infrastructure server suite. It provides multiple subsystems: Certificate Authority (CA) for certificate lifecycle management, Key Recovery Authority (KRA) for key archival and recovery, Online Certificate Status Protocol (OCSP) responder, Token Key Service (TKS) for smart card key handling, Token Processing System (TPS) for token management, and ACME/EST responders for automated certificate enrollment. The system exposes REST APIs (both JAX-RS v1 and servlet-based v2), a rich CLI toolset (Java and Python), and a legacy Swing admin console (deprecated). Backend storage primarily uses LDAP (389 Directory Server) for certificates, requests, and configuration, with PostgreSQL optionally used for ACME realms. The architecture follows a modular monolith pattern: each PKI subsystem runs as a separate Java web application deployed on Apache Tomcat, sharing common libraries from base/common and base/server. Cryptographic operations are handled via NSS (Network Security Services) and JSS (Java Security Services). Key patterns include a ConfigStore hierarchy for type-safe configuration access, a JSONSerializer interface for consistent data serialization, a CommandCLI base class for building CLI commands, and a policy/profile framework for certificate issuance rules. The codebase demonstrates strong engineering with extensive test coverage (unit, integration, CI workflows), Docker support, and versioned upgrade scripts. While the codebase is actively maintained with frequent commits and a comprehensive CI pipeline, it shows signs of technical drift: a large volume of deprecated Swing console code marked for removal, persistent use of legacy com.netscape package names alongside newer org.dogtagpki packages, and a polyglot codebase (Java, Python, native C++ for TPS client) that increases maintenance complexity. The quality is solid overall with well-separated concerns and reusable patterns, though the sheer scale and historical accumulation of components prevent it from being considered exceptional.
ComfyUI-VoxCPM is a ComfyUI custom node package that provides expressive text-to-speech (TTS) using the VoxCPM model family (v1.x and v2). It supports zero-shot TTS, voice cloning (prompt or reference audio), voice design via text descriptions, LoRA inference, and LoRA fine-tuning. The architecture is a ComfyUI extension with heavy JavaScript frontend, HTTP API routes, and vendored model inference code. The core functionality is implemented in the `src/voxcpm/` directory, which contains model architectures (MiniCPM4, AudioVAE, local DiT, etc.), a standalone CLI, and training utilities. External dependencies include ComfyUI, PyTorch, Hugging Face Hub, and several optional libraries (argbind, datasets, modelscope, etc.). The codebase demonstrates good software engineering practices with clean abstractions, reusable components, and graceful degradation for optional features. However, it is tightly coupled to ComfyUI's ecosystem and vendors upstream model code, which may drift from upstream. The repository also includes a standalone `hf_progress` library for HuggingFace transfer progress tracking, which is a well-isolated, reusable component.
pyGIMLi is a mature open-source geophysical modelling and inversion library, implemented as a C++ core with Python bindings. It provides mesh generation, finite-element solvers, data containers, and high-level manager classes for methods such as electrical resistivity tomography (ERT), vertical electrical sounding (VES), frequency-domain electromagnetics (FDEM), magnetics, gravity, traveltime, and spectral induced polarization. The library is not a GUI application; it is a programmatic toolkit with Python entry points, example scripts, and a console-app pattern in some managers.
The Allegro package implements the Allegro E(3)-equivariant machine learning interatomic potential as an extension for the NequIP framework. It provides a neural network architecture that predicts energies and forces in atomic systems while being invariant to translations, rotations, and reflections. The model is built using a combination of scalar and tensor feature tracks, interacting through tensor product layers, and is designed to be strictly local with a configurable cutoff radius. The architecture centers around the `AllegroModel` function, which constructs a graph neural network. Input atomic data (positions, types, and optionally cell) is processed through embedding layers to generate initial scalar and tensor features. These features then pass through multiple Allegro layers, each consisting of tensor product operations (via the `Contracter` module) and mixing layers (MLPs). The final features are reduced to per-atom energies, summed to get the total energy, and forces and stresses are computed via automatic differentiation if requested. Key entry points include the `AllegroModel` function and the package's entry point for NequIP integration. The package relies on external dependencies such as NequIP, PyTorch, and e3nn, with optional accelerations via NVIDIA's CuEquivariance library or custom Triton kernels for GPU performance. The codebase demonstrates strong engineering practices, including performance optimizations for the tensor product bottleneck (through both the base `Contracter` implementation and GPU-accelerated variants), a clear modular structure, and comprehensive testing. Reusable components such as the `Contracter` and `MakeWeightedChannels` modules showcase efficient tensor product handling and feature weighting strategies that could be adapted to other equivariant neural network architectures with minimal modification.
AL-Go for GitHub is a comprehensive CI/CD framework and template system for Microsoft Dynamics 365 Business Central AL extension development. It provides a set of reusable GitHub composite actions, PowerShell modules, and starter workflow templates that automate building, testing, signing, deploying, and delivering AL apps to AppSource, NuGet, Azure Storage, GitHub Packages, and Business Central environments. The system supports multi-project repositories, incremental builds, workspace compilation, code analysis with SARIF output, performance testing, Power Platform solution integration, self-updating system files, and extensive telemetry. The architecture is action-centric: each action is a `action.yaml` + PowerShell script, invoked via a consistent wrapper (`Invoke-AlGoAction.ps1`) that handles errors, telemetry, and secret injection. Settings are JSON-driven with a schema, and behavior can be customized via hooks, script overrides, and conditional settings. The repository also includes a full Pester unit test suite, end-to-end test harness, and workshop documentation. While well-crafted with clean separation of concerns, the codebase exhibits some technical drift due to deprecated settings, duplication between Per Tenant Extension and AppSource App templates, hardcoded external URLs, and reliance on external PowerShell modules (BcContainerHelper, Az modules) which may introduce fragility.
This is a TypeScript-based danmaku (bullet screen/comment overlay) library for the web. It provides a manager-based architecture to push, render, and animate danmaku over video or any DOM container. The library offers two types of danmaku: facile (scrolling) and flexible (custom-positioned), with collision detection modes (none, strict, adaptive) and a track system for lane management. Rendering is done via CSS transitions, enabling rich customization and integration with any UI framework (the demo uses React). The library has a comprehensive plugin system via hooks-plugin, allowing developers to hook into lifecycle events at both manager and danmaku level. It is well-structured, with clean separation of concerns (Manager, Engine, Container, Track, Danmaku classes), and includes utility functions for expression-based size calculations. The demo application is a full-featured control panel for testing all configurable options. The repository also includes extensive documentation (VitePress) with both English and Chinese locales.
This repository is a production-grade React mobile UI component library, `@arco-design/mobile-react`, developed by ByteDance. It provides over 60 components for building mobile web applications, including form controls, navigation, overlays, media, and feedback elements. The architecture is a Lerna monorepo with separate packages for components, shared utilities, and design tokens. The library supports theming via CSS variables (light/dark mode), internationalization (10+ locales), platform-specific styling (iOS/Android), and responsive layout using rem. It also includes comprehensive documentation sites (PC and mobile) generated from markdown. While the codebase demonstrates solid engineering practices with reusable hooks and patterns, it shows some technical drift due to outdated dependencies (React 16, TypeScript 4.1, Lerna v4) and a complex build pipeline (webpack, rollup, gulp, vite). Several components are well-crafted and isolatable, making this library a valuable resource for teams building mobile React UIs.
This repository is a Docusaurus v3+ plugin that provides offline/local search functionality. It operates in two phases: at build time, it parses the generated HTML pages (docs, blog, static pages) using cheerio, extracts text and metadata, and builds Lunr.js search indexes per documentation version/language. At runtime, it serves a React-based search bar using @algolia/autocomplete-js that fetches the pre-built index JSON and performs client-side searches with Lunr. The plugin supports multiple languages, documentation versions, i18n, and configurable boosting of title/content/tags. It is a well-engineered monorepo with a single plugin package and an example Docusaurus site for testing. The code is TypeScript, has unit and e2e tests, and follows modern development practices (pnpm workspaces, Turborepo, conventional commits).