FRP Manager is a Windows desktop application that provides a graphical interface for managing FRP (Fast Reverse Proxy) client configurations. It allows users to create, edit, launch, stop, and monitor multiple FRP proxy configurations, supporting both legacy INI and modern TOML formats. The application can run as a standard GUI or as a Windows service, with real-time status updates via IPC between the GUI and the service process. It includes features such as quick-add proxy presets (SSH, RDP, FTP, etc.), import/export via file, URL, or clipboard, NAT type discovery, master password protection, and multi-language support (6 languages). The installer is a native Windows bootstrapper that extracts an MSI and handles service lifecycle during upgrades. The architecture is monolithic: the main entry point in `cmd/frpmgr/main.go` decides whether to launch the GUI or run as a service. The UI layer uses the `lxn/walk` library (a custom fork) for native Win32 controls, organized into pages (configuration, log, preferences, about). The service layer wraps the official `fatedier/frp` client library and manages Windows service installation, start/stop, and configuration reload. IPC is implemented via named pipes for status updates. Configuration parsing and validation are handled in the `pkg/config` package, with conversion between INI and TOML. The project also includes a comprehensive i18n system using `gotext`, a set of reusable validators, and utility functions for file operations, string manipulation, and reflection-based config pruning. External dependencies include the FRP library (`fatedier/frp` v0.71.0), the forked `lxn/walk` GUI library, Windows API bindings (`golang.org/x/sys/windows`, `github.com/Microsoft/go-winio`), and WiX Toolset for the installer. The build process requires Go 1.25, MinGW, Node.js, and Windows SDK. The codebase is well-structured with clear separation of concerns, though it is tightly coupled to Windows and the forked walk library, limiting portability. Test coverage is present for core packages (config, validators, utilities) but sparse for UI and service components.
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.
The `av` CLI tool manages stacked Git branches and their associated GitHub pull requests in an automated workflow. It allows developers to create dependent branches, automatically rebase child branches when parents change, synchronize local state with GitHub (fetches, pushes, prunes merged branches), and interactively reorder or squash commits across a stack. The system uses a local JSON file database (`av.db`) to persist branch metadata and PR associations, a GraphQL client to communicate with GitHub, and a Bubbletea-based terminal UI for interactive prompts and progress spinners. It consists of Cobra command definitions, a git operations wrapper (mix of `go-git` and direct exec), and a state-machine sequencer for multi-step rebase operations with conflict handling. The architecture is modular with clear separation between git operations, GitHub API, state management, and user interface, making it a solid example of a domain-specific developer tool.
KLDNS is a production-grade, multi-tenant subdomain distribution and DNS management SaaS platform. Users register subdomains under administrator-managed parent domains, pay with an internal points economy, and create/manage DNS records that are synchronously written to external DNS providers. The backend is a layered Go application (Gin HTTP handlers → services → SQLite repositories via GORM plus raw SQL) with an embedded migration system, and the frontend is a Vue 3 + TypeScript + Element Plus SPA that gets compiled and embedded into the Go binary at release time. This is purely an application repo — no data research, pipelines, or analytics artifacts are present. The core workflows are: subdomain registration with points deduction and a pending-review approval workflow (with refunds on rejection), DNS record CRUD that writes remote provider APIs first and the local database second (with compensation deletes and a dns_write_jobs queue for failed remote operations), session/API-token authentication with hashed secrets, Cloudflare Turnstile captcha verification, and a full admin backend for users, groups, domains, provider credential configs, settings, and audit logs. DNS provider integrations use a factory-registered interface with adapters for Cloudflare, DNSPod, Aliyun, AWS Route53, Google Cloud DNS, Huawei, Baidu, and others — several implementing non-trivial signing schemes (AWS SigV4, Google JWT/OAuth2, Huawei SDK-HMAC-SHA256, Baidu BCE). Testing is a notable strength: services, repositories, utilities, and most provider adapters have unit tests using httptest servers, fake repositories, and fixed-time fixtures. The main weaknesses are internal consistency issues rather than broken functionality: duplicated domain/subdomain join SQL across repositories, a documented repository refactoring in progress, hardcoded magic values (admin group 99, default group 100), two different pagination strategies between admin (server-side) and user (client-side) frontend views, Chinese-language UI and error messages not abstracted behind localization, and a hardcoded default app secret that must be changed in production. The multi-provider DNS abstraction, crypto/validation utilities, and the embedded migration runner are genuinely reusable in other Go projects.
LeanKG is a Go-based knowledge graph engine for AI-assisted development. It indexes source code from multi-language repositories into a graph of elements (functions, types, classes) and relationships (calls, imports, implements), stored in SQLite or PostgreSQL with optional vector embeddings for semantic search. The system provides a CLI, REST API, MCP (Model Context Protocol) server, and a React web UI (force-directed graph, file tree, code panel). Core capabilities include incremental indexing with three-signal change detection, a four-tier query ladder (cold/exact/fuzzy/semantic), impact analysis with blast radius, organizational knowledge management (incidents, notes, env reports), ontology matching, federation across servers, and token-budgeted compression for AI tool integration. The architecture is modular: the store backend interface supports SQLite and PostgreSQL with a shared migration ledger; indexing uses regex extractors for 40+ languages with an optional tree-sitter CGO tier; embeddings use a provider abstraction (OpenAI-compatible, llama.cpp sidecar, deterministic). The codebase is well-structured with extensive tests, hermetic test patterns, and deterministic output design. Notable reusability includes the compress package (shell output, git diff), auth token system, store abstraction pattern, and A/B benchmarking harness.
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.
Clawgo is a minimal headless Go client node for the Clawdbot voice assistant gateway. It connects to a bridge over TCP, handles pairing and authentication, then streams voice transcripts from stdin, a FIFO, or a subprocess STT engine (brabble) as `voice.transcript` or `agent.request` events. It supports bidirectional chat: it can subscribe to chat events and speak responses via local TTS (espeak-ng or custom command) through a serialized speech queue. The node advertises itself via mDNS and supports configurable routing plugins for pre-processing transcripts (e.g., quick actions like 'telegram ping'). The architecture is a single binary with a reconnection loop, context-cancellable waits, and graceful shutdown on SIGINT/SIGTERM. The codebase demonstrates solid Go practices: clean separation of concerns, a plugin registry for routing policies, a thread-safe TTS queue that cancels active speech on disconnect, and careful handling of external subprocess stdout/stderr.
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.
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.
Mythic is a cross-platform, post-exploitation, red teaming command-and-control (C2) framework. It enables operators to manage remote agents (callbacks), generate payloads, issue tasks, exfiltrate files, harvest credentials, and automate workflows through an event-driven system. The architecture is a multi-container Docker deployment: a Go backend (using Gin, RabbitMQ, PostgreSQL, gRPC) handles agent communication, task orchestration, and data persistence; a React frontend (Material-UI, Apollo Client) provides a rich operator interface with real-time updates via GraphQL subscriptions (backed by Hasura); and a CLI tool (Mythic_CLI) manages container lifecycle, configuration, and service installation. Key entry points include the agent message webhook (HTTP POST/GET), web controllers for CRUD operations, and RabbitMQ RPC handlers for internal service communication. External dependencies include RabbitMQ, PostgreSQL, Hasura GraphQL engine, Docker, and gRPC. The system is designed for extensibility through payload type containers, C2 profiles, translation containers, and custom browser scripts.
Plow is a high-performance HTTP(S) benchmarking CLI tool written in Go. It uses fasthttp for efficient HTTP client operations and provides real-time metrics including latency statistics, percentiles, histograms, and throughput. The tool supports configurable concurrency, request rate limiting, ramp-up, duration-based or request-count-based runs, and custom headers, body, TLS, and proxy settings. It outputs results to the terminal with live updating tables and also serves a web UI with interactive charts (latency, RPS, status codes, concurrency) using go-echarts. The architecture is a single binary with three main components: a requester that spawns concurrent workers, a stream-based report aggregator that computes streaming quantiles and histograms, and a printer/chart server for output. The code is well-structured, thoroughly tested, and follows Go best practices. It is not a library but a standalone application, though some internal components (e.g., the streaming stats engine and throughput interceptor) are cleanly isolated and could be reused in other projects.
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.
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 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.
This repository is a Go SDK and command-line tool for managing Proxmox VE. The core `proxmox` package provides typed configuration structs and client interfaces for nearly every Proxmox resource: QEMU VMs, LXC containers, storage backends, users, groups, pools, API tokens, snapshots, ACME accounts, metric servers, HA rules, SDN, and content templates/ISOs. The SDK maps strongly-typed Go structs to and from Proxmox's `/api2/json` endpoints, with pervasive validation, version-aware feature gates, and both legacy and modern client layers. A Cobra-based CLI in `cli/` exposes these operations to end users, while a deprecated `main.go` still exists for legacy command-line usage.
FeedCraft is a self-hosted feed processing service that transforms raw sources (RSS, Atom, HTML, JSON, search results, inbox pushes) into customized RSS feeds through composable processing pipelines called 'crafts'. The system is a monolith Go backend with a Vue 3 admin dashboard, exposing REST APIs for feed ingestion, transformation (AI-powered translation, summarization, full-text extraction, filtering), and aggregation into 'topic feeds'. The architecture follows a clean separation of concerns: source fetching/parsing, craft processing (atomic operations and flows), engine runtime, and administrative controllers. External dependencies include SQLite/PostgreSQL, Redis, an OpenAI-compatible LLM, a browserless service for dynamic content, and optional embedding APIs for semantic filtering. The codebase demonstrates solid engineering with interfaces for sources, parsers, crafts, and caching, though it carries some migration complexity from legacy craft models to newer ones.
This is a desktop application built with Go and the Fyne GUI framework that manages updates for portable Chrome installations and Chrome++ (a Chrome enhancement tool). It provides a graphical interface to check for the latest Chrome versions across stable, beta, dev, and canary branches, download them using a multi-threaded downloader with resume support, and extract 7z archives. It also supports updating Chrome++ from GitHub releases, system tray integration with auto-update scheduling, proxy configuration, and localization (English/Chinese). The application communicates with Google's Omaha update protocol (via XML requests to tools.google.com) and a custom web service (chrome.noki.eu.org) to fetch version information. The codebase demonstrates solid engineering practices including data binding, concurrent downloads, and a clean i18n system using embedded TOML files.