CoAI (formerly ChatNio) is a full-stack AI chat platform and LLM gateway that provides a unified chat interface and OpenAI-compatible API proxy for 16+ AI model providers (OpenAI, Anthropic Claude, Google Gemini, Midjourney, DeepSeek, etc.). The system is built with a Go backend (Gin framework) and a React/TypeScript frontend (Redux, Tailwind CSS, Radix UI), with MySQL and Redis for persistence and caching. It supports real-time WebSocket chat, streaming responses, conversation management, file upload, web search, image generation, and a plugin system (MCP). The platform includes a comprehensive billing and subscription system with elastic per-token pricing and tiered plans (Basic/Standard/Pro), along with an admin dashboard for user management, channel configuration, analytics (model usage, request volume, revenue, errors), and system settings. It also features invitation codes, redeem codes, affiliate marketing, and multiple payment gateway integrations (Stripe, WeChat Pay, etc.). Architecturally, the backend employs an adapter pattern for AI providers, a channel manager for load balancing and retries, and a WebSocket connection manager with rate limiting. The frontend is heavily componentized with shadcn/ui and includes i18n support (English, Chinese, Japanese, Russian). Deployment is supported via Docker Compose, Zeabur, and a Tauri desktop app. While the codebase is well-structured and feature-rich, it shows signs of technical drift such as copy-pasted processor files across adapters, hardcoded model constants, and a large dependency surface. The open-source version is Apache 2.0 licensed, with a commercial 'CoAI Pro' tier offering additional features.
OVH CDS is an enterprise-grade continuous delivery and DevOps automation platform. The repository contains a set of Go services (API, CDN, hooks, VCS, repositories, hatcheries, worker, elasticsearch) managed via a common engine binary, supported by PostgreSQL, Redis, and OpenSearch/Elasticsearch, plus an Angular web UI, a cdsctl CLI, and gRPC-based action/integration plugins. In production it orchestrates pipelines and workflows, spawns workers on Kubernetes, Swarm, OpenStack, vSphere or local hosts, ingests VCS webhooks, stores job logs and artifacts through a pluggable CDN storage layer, and enforces fine-grained RBAC across projects, regions, workflows, and variable sets. Both legacy v1 workflows and newer as-code v2 workflows are implemented and actively maintained side-by-side.
Kaiju Engine is a full-featured 2D/3D game engine written in Go, backed by Vulkan for rendering. It includes a built-in editor that runs as a game within the engine, providing workspaces for stage management, shader design, render graph editing, terrain painting, and content browsing. The engine core handles entity management, physics (custom Graviton engine with rigid bodies, constraints, and collision detection), audio (SoLoud via CGo), networking (UDP with reliability), UI (custom HTML/CSS markup engine with flexbox/grid layout), asset pipeline (glTF, FBX, textures, fonts), and cross-platform support (Windows, Linux, macOS, Android). The editor adds undo/redo history, action system with key bindings, Lua scripting, a Web API, and a plugin system. The codebase is a monorepo with heavy use of Go build tags for platform-specific code and feature flags.
EdgeVPN is a decentralized peer-to-peer VPN and overlay networking tool built on libp2p. It provides a VPN tunnel (TUN interface), TCP service tunneling (ngrok-like), HTTP egress proxy, DNS resolution, file transfer, and a distributed ledger for network state coordination. The architecture is a single Go binary with an embedded React SPA dashboard, exposing a REST API (Echo framework) and CLI (urfave/cli v2). The core innovation is a blockchain-style ledger that stores machine, service, DNS, and health records, with optional signed ownership enforcement and liveness-based reaping. The system uses libp2p for peer discovery (DHT, mDNS), pubsub (gossipsub), relays, and circuit v2. It is designed for decentralized networks without central coordination, and is used in production by Kairos (Kubernetes) and LocalAI (P2P distribution). The codebase demonstrates strong engineering with functional options patterns, comprehensive test suites, documentation generation from CLI code, and a design system for the React UI. However, it carries technical debt from experimental features (PeerGuard, DHCP, IPv6), a forked libp2p-pubsub dependency, and documentation drift that requires manual regeneration.
go-workflows is a Go library for building durable, fault-tolerant workflow applications. It implements an event-sourced execution engine inspired by Temporal/Cadence: workflows are modeled as histories of events, and workers execute them by replaying those histories against backend queues. The library exposes a public client API for starting, signaling, and waiting on workflows, and provides a workflow/activity authoring model with sub-workflows, timers, signals, retries, cancellation, and context propagation. Execution is built on a custom coroutine-based async runtime (internal/sync) that gives workflows deterministic control flow, and multiple storage backends (Redis, MySQL, PostgreSQL, SQLite, plus in-memory/monoprocess) implement the same backend interface. Key entry points include the client package, the worker package, the workflow/activity authoring packages, and the tester package for unit testing workflows without a real backend. The repository also contains a separate static analyzer module (analyzer/) that enforces workflow determinism at compile time, and a benchmark tool (bench/) for comparing backend performance. External dependencies include OpenTelemetry for tracing, slog for structured logging, and backend-specific drivers for Redis, MySQL, PostgreSQL, and SQLite. CI runs tests with the race detector across all backends, and Docker Compose provides the required databases. The codebase is substantial and well-tested, but carries maintainability debt: each backend duplicates significant logic (diagnostics queries, event insertion), Redis uses hand-written Lua scripts that can drift, and the embedded diagnostic web app requires a separate Node.js build step. The separate analyzer module also risks version drift from the main module. Despite these caveats, the core abstractions are clean and several components are genuinely reusable.
Pegomock is a mocking framework for the Go programming language that generates mock implementations of interfaces for testing purposes. It provides a DSL inspired by Mockito for defining mock behavior and verifying interactions. The project consists of a core library for creating and verifying mocks in tests, a CLI tool for generating mock code from interfaces, and a watch mode that automatically regenerates mocks when interfaces change. The architecture follows a modular design with separate components for the DSL, mock generation, and CLI functionality.
SLRP is a rotating open proxy multiplexer that automatically discovers, validates, and rotates proxies from dozens of online sources. It runs as a single Go binary with an embedded Web UI and provides both a REST API and an MITM HTTP/HTTPS proxy endpoint. Internally, it uses a modular architecture with components for source scraping, proxy checking, pool management, request history recording, and IP geolocation. It features a custom query language for filtering proxy pool, history, and blacklist data, and includes a code generator to create type-safe dataset accessors from Go struct definitions. The system persists state to disk and can be configured via YAML or environment variables.
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.
Goravel is a full-featured web application framework for Go that follows Laravel-inspired patterns and conventions. It provides a comprehensive set of tools for building web applications including HTTP routing, controllers, middleware, ORM, authentication, authorization, caching, queues, events, scheduling, and more. The framework uses a service container with facade pattern for easy access to services while maintaining testability, and employs service providers for modular bootstrapping of application components. The architecture is modular monolith with clear separation of concerns: application logic in app/, configuration in config/, routes in routes/, database migrations in database/migrations/, and tests in tests/. Entry points include main.go for application startup and artisan for CLI commands. The framework integrates with popular Go libraries like Gin for HTTP routing, GORM for ORM, and OpenTelemetry for observability.
HotGo is a full-stack rapid application development framework built on GoFrame (Go) and Vue 3 (Naive UI). It provides an admin panel with RBAC, multi-tenancy, code generation, plugin/addon system, and integrations for payments (Alipay/WeChat/QQ), SMS, email, file storage (local/S3/MinIO/COS/OSS), message queues (Redis/Kafka/RocketMQ/disk), WebSocket real-time messaging, TCP server with RPC, and cron scheduling. The backend follows a modular service layer with generated DAO/entity patterns and custom ORM handlers for data filtering, tenant isolation, and sorting. The frontend is a dynamic SPA with built-in components for tables, forms, modals, uploads, and charts, plus i18n support. The codebase is production-ready but heavily relies on code generation and custom forks of GoFrame CLI tools, introducing some maintenance risk. Designed primarily for Chinese developers building enterprise admin systems.
Hermes is an open-source document management system developed by HashiCorp for creating, reviewing, approving, and publishing internal technical documents (RFCs, PRDs, FRDs). It provides a full-stack application with a Go REST API backend, an Ember.js web frontend, and a Microsoft Word add-in (React/Fluent UI) for editing document metadata directly in documents. The system supports dual content backends: Google Workspace (Drive, Docs, People API) and Microsoft SharePoint/Microsoft Graph, with file storage, permission management, and email notifications. Search is powered by Algolia with faceted filtering, and persistent storage uses PostgreSQL via GORM, though the architecture is in transition from Algolia as the primary data store to PostgreSQL. Authentication supports Google OAuth, Microsoft OAuth, and AWS ALB OIDC/Okta. The API exposes REST endpoints under `/api/v1/` and `/api/v2/` for documents, drafts, approvals, reviews, projects, people, products, and subscriptions. Key background processes include a document indexer that synchronizes file metadata to Algolia and a migration command to move data from Algolia to PostgreSQL. The Ember frontend provides a dashboard, document browsing with advanced search, project management, and settings. The Office add-in enables users to manage related resources, update document status, and edit custom fields without leaving Word. Externally, Hermes depends on Google Workspace APIs, Microsoft Graph API, Algolia, PostgreSQL, and optionally Datadog for tracing and Google Analytics for frontend metrics. It is configured via HCL files and environment variables, with Docker and Docker Compose support for local development. The project is in alpha stage and not an official HashiCorp product, but it is actively developed with CI/CD pipelines, extensive unit/integration tests (Go, Ember QUnit), and a comprehensive test harness using Mirage for the frontend.
Ganymede is a media management system focused on archiving and managing Twitch content (VODs, live streams, clips) with a Go backend using Ent ORM, Echo framework, and River job queue, and a Next.js frontend with Mantine UI. It provides video archiving, playlist management, user authentication, API keys, and administrative interfaces. The system processes media through a pipeline involving yt-dlp, FFmpeg, and TwitchDownloaderCLI, storing metadata in PostgreSQL and files on disk. It includes features like chat archiving, chapter detection, muted segment detection, and rule-based playlist automation.
This repository is a suite of Kafka cluster management tools developed by DataDog. It provides four primary tools: `topicmappr` for partition reassignment and rebalancing with storage-aware placement, `registry` for a gRPC/HTTP API that exposes Kafka metadata and custom tagging, `autothrottle` for dynamically adjusting replication throttles based on Datadog network metrics, and `metricsfetcher` for pulling partition size and broker storage metrics from Datadog into ZooKeeper. The architecture is a collection of independent CLI binaries and a gRPC server, all sharing well-factored Go libraries (`kafkaadmin`, `kafkazk`, `mapper`) that abstract Kafka admin operations, ZooKeeper interactions, and partition mapping logic. The codebase is production-grade, with extensive unit and integration tests, Docker-based development environments, and CI pipelines. It is tightly coupled to Datadog for metrics and ZooKeeper for metadata, which introduces some drift risk as Kafka evolves away from ZooKeeper. The last commit date (2026-09-16) appears anomalous and may indicate a timestamp issue, but the repository shows active maintenance with recent CI configurations and issue triage.
The chans package is a Go library that provides a set of generic channel operations for building concurrent pipelines. It offers functions for filtering, mapping, reducing, batching, windowing, de-duplication, and routing data through channels. Each function is designed to be composable, allowing developers to construct complex data processing flows by combining these building blocks. The package stands out for its consistent handling of context cancellation across all functions, ensuring that pipelines can be gracefully terminated. A key insight in the implementation is the use of internal helper functions (forEach, whileTrue, untilErr) that abstract the common pattern of iterating over a channel with context awareness. This reduces boilerplate and ensures that every function correctly handles cancellation and channel closure. The Merge function, which fans in multiple input channels using goroutines, is another example of careful concurrency management. Designed to be unopinionated and flexible, chans gives developers full control over channel lifecycle and concurrency patterns. Unlike some other concurrency libraries, it does not impose specific goroutine patterns or error handling strategies, instead providing low-level primitives that can be adapted to various use cases. The package has zero external dependencies beyond the Go standard library, making it easy to integrate into any Go project.
This repository implements a production-grade Google Maps business data extraction platform with multiple execution modes: CLI, web UI, REST API, AWS Lambda, and a self-hosted SaaS edition. The core scraping engine uses Playwright for browser automation and also supports a stealth HTTP fast mode. It extracts 36+ structured fields per business (name, address, phone, website, reviews, ratings, emails, coordinates, hours, etc.) and provides deduplication, grid-based area coverage, email extraction via website visits, and review parsing. The architecture is modular with packages for scraping jobs, runners (file, database, web, Lambda, SaaS worker), output writers (CSV, JSON, PostgreSQL, S3, custom plugins), job queuing via River, and a comprehensive admin dashboard with cloud provisioning on DigitalOcean and Hetzner. The system is designed for both single-user CLI use and multi-tenant SaaS deployments with authentication, 2FA, API key management, and scalable worker pools. The codebase demonstrates strong Go engineering practices with well-defined interfaces, dependency injection, and test coverage. Notable reusable components include cryptography utilities, HTTP server middleware, rate limiting, and a CLI prompt library. However, the repository has some maintenance concerns: two separate database migration sets for legacy and SaaS modes, in-memory deduplication that doesn't persist across restarts, committed test SSH keys in the `local/` directory, and a large dependency surface that could introduce version conflicts. The scraper logic is inherently brittle due to reliance on Google Maps internal data structures, which are subject to change without notice. For AI agent consumption: This is a powerful off-the-shelf scraping tool that can be deployed as a Docker container, AWS Lambda, or managed SaaS. It provides a complete API and web interface for managing scraping jobs, monitoring progress, and exporting data. The SaaS edition includes worker auto-provisioning, making it suitable for large-scale lead generation operations. The code is actively maintained with recent commits addressing performance and feature enhancements.
Kaitai Struct is an umbrella project that provides a declarative language for describing binary data structures and a compiler to generate parser code in multiple target languages. The repository coordinates submodules for the compiler, runtimes for various languages (Java, Python, Ruby, etc.), format definitions, visualizer, tests, benchmarks, and documentation. Users describe a format in a .ksy file, compile it with the kaitai-struct-compiler to generate language-specific parser code, and use the corresponding runtime to parse binary data. The project includes CI workflows for building the compiler and publishing artifacts, and maintains a collection of ready-to-use format descriptions.
This repository is a production-oriented Go client library for the Binance cryptocurrency exchange, covering spot, margin, USDS-M futures, coin-margined delivery futures, options, portfolio margin, and related products. The code in v2/ exposes fluent builder-style services for REST endpoints and WebSocket streams, with clients such as NewClient, NewFuturesClient, NewDeliveryClient, NewOptionsClient, and portfolio-specific clients. The library is consumed by trading bots and exchange-integration applications; it is not a data analysis or research project, though it provides market-data access primitives for klines, tickers, order books, funding rates, and historical trades.
GoInterruptPolicy is a Windows GUI utility for managing interrupt affinity (IRQ affinity) of hardware devices. It enumerates devices through the Windows SetupAPI, reads their current interrupt policy from the registry, and lets users assign interrupts to specific CPU cores, including Intel P-cores/E-cores, AMD CCDs, and NUMA nodes. The practical goal is reducing interrupt latency for real-time workloads such as gaming and audio processing. The code is Windows-only and packaged as a standalone Go executable with an icon, manifest, and version resources.
git-backup is a CLI tool written in Go that backs up all Git repositories from GitHub and GitHub Enterprise (including GitLab) to local storage. It uses the go-git library to perform bare or non-bare clones without requiring the git CLI. The configuration is driven by a YAML file that supports Go templating for environment variable injection. The tool discovers repositories via the provider APIs using configurable filters (owned, starred, collaborator, org member) and excludes specific repos or namespaces. Pagination is handled automatically. It supports Docker deployment with UID/GID mapping. The code is well-structured with clear separation of providers (GitHub, GitLab) behind a common RepositorySource interface. It is a focused, standalone backup solution that does not require external dependencies beyond the binary itself.
Dublin Traceroute is a NAT-aware multipath traceroute tool that extends the Paris-traceroute technique to enumerate ECMP load-balanced paths and detect NATs. It forges UDP packets with custom payloads to control the UDP checksum, which is used as a per-flow identifier and embedded in the IP ID field for NAT correlation. The system listens for ICMP Time Exceeded and Destination Unreachable responses, matches them to sent probes using IP ID (IPv4) or payload length (IPv6), and computes a NAT ID from checksum differences. Output is provided in JSON or DOT format for visualization. The repository contains two independent implementations: a primary C++ library/CLI using libtins and jsoncpp, and an experimental Go implementation with IPv6 support and additional tooling (routest for integration testing). The Go implementation demonstrates cleaner separation of concerns with reusable network protocol modules (ICMP, UDP, IPv6) and a layered protocol abstraction.