language · language
Filter in Explore Go
26 production projects and 2 rule sets built with Go.
Production projects
- Self-Hosted Real-Time Push Server Classic Gotify Gotify keeps the server one deployable Go binary by embedding its Vite/React web UI, using Gin and gorilla/websocket for the REST and streaming API, and swapping SQLite, MySQL or PostgreSQL through GORM, while a compiled Go plugin system handles extensibility instead of a scripting layer.
- Monitoring & Observability Dashboard Classic Grafana Grafana splits its backend into a growing set of independently versioned Go modules under apps/, tied together by a go.work workspace and modeled with Kubernetes-style APIs (pkg/apiserver, CUE-defined kinds), so individual product areas like alerting or dashboards can evolve without one monolithic backend module.
- Distributed Blob & File Storage Classic SeaweedFS Decoupling directory metadata from physical volume storage eliminates central metadata bottlenecks, enabling massive horizontal scaling for small and large files alike.
- Team Collaboration Suite Classic Mattermost A single Go binary keeps the API, scheduler, and websocket hub in one deployable process backed by a required PostgreSQL database, while optional Redis, Elasticsearch, and OpenSearch clients let larger deployments add caching and full-text search without changing the core architecture.
- LLM Knowledge Base & RAG Platform Classic WeKnora Retrieval, agents and the API sit in one Go service, and parsing is delegated to a Python gRPC service. Storage backends are pluggable, so the same codebase runs as a lite SQLite binary or a full Kubernetes deployment on existing Postgres, Elasticsearch or vector databases.
- Hybrid Deterministic + LLM Agent Code Review Tool Hybrid Open Code Review A single static Go binary keeps the review engine fast and easy to distribute through npm, CI and IDE plugins. Putting deterministic diff/context analysis before a narrow LLM loop keeps reviews precise and cheap in tokens compared with general-purpose agents.
- Instant GraphQL Engine & Unified Data Access Classic Hasura Hasura runs two independently evolving query engines from one repository — a Haskell V2 server and a Rust V3 engine — and extends database support through an out-of-process Data Connector protocol, so a new database backend plugs in as a separate agent instead of new code inside either engine.
- Lightweight Self-Hosted Git Service Classic Gitea One Go process fronted by XORM abstracts four relational databases and pluggable search/storage backends, so the same codebase scales from a single SQLite file on a Raspberry Pi to a MySQL- or PostgreSQL-backed team instance.
- High-Performance S3 Object Storage Classic MinIO Implementing erasure coding, IAM, and multi-protocol event notifications directly in the Go server, instead of delegating to RAID or an external message broker, keeps a deployment to a single binary while still integrating with existing enterprise identity and messaging systems through native client libraries.
- Lightweight Server & Container Monitoring Classic Beszel Building the hub on PocketBase gives Beszel a REST API, auth, realtime updates, and SQLite storage from one embedded framework, while a separate Go agent binary keeps the footprint on monitored systems minimal, matching its stated goal of being lighter than existing monitoring solutions.
- Authentication & SSO Proxy Companion Classic Authelia A single fasthttp-based Go binary keeps the authentication portal, OIDC provider, and MFA logic in one process with pluggable SQLite/MySQL/PostgreSQL storage, so it can run as a zero-dependency single instance or scale out with a shared database.
- Multi-Threaded In-Memory Key-Value Store Classic Dragonfly A fiber-based, shared-nothing execution model (one thread and one keyspace shard per core) lets Dragonfly scale vertically across cores, which single-threaded Redis cannot do without external sharding, while staying protocol-compatible so existing clients need no changes.
- Multi-Model AI Agent & Chat Workspace Hybrid LibreChat A Node/Express API with a Mongoose-modeled MongoDB store handles chat state, while Vite builds the React client separately; optional Docker sidecars for pgvector, Meilisearch, and a Go OpenTelemetry relay keep RAG, search, and observability decoupled from the core API.
- Personal Health Records & Medical EHR Engine Classic Fasten Health A single distroless Docker image embeds the Angular build inside the Go binary and defaults to file-based SQLite so a family can self-host medical records without provisioning a separate database or web server.
- Q&A & Developer Knowledge Community Classic Apache Answer A statically linked Go binary that embeds its React UI and supports SQLite, MySQL or PostgreSQL keeps deployment to one container, while typed plugin interfaces extend auth, storage, search and AI without forking.
- Distributed Workflow Orchestrator Classic Temporal Temporal keeps workflow code in external workers and persists every state transition as an event history that the Go gRPC cluster (Frontend, History and Matching services) replays after crashes or restarts, so long-running workflows survive failures on PostgreSQL, MySQL, SQLite or Cassandra storage.
- Federated GraphQL API Gateway Hybrid Cosmo (WunderGraph) Splitting the Go router (runtime query execution) from the TypeScript Controlplane (schema registry and management) lets Cosmo scale and deploy the performance-critical data path independently, while a dedicated ClickHouse-backed metrics service keeps high-volume usage analytics off the primary Postgres database.
- Automated Health Dashboard & Status Monitor Classic Gatus The whole product ships as one Go binary with the Vue dashboard embedded via go:embed and YAML-defined check conditions, so a status page needs no separate frontend server and, by default, no external database.
- Identity Provider & Access Management Classic Authentik Replacing Redis with three purpose-built PostgreSQL-backed packages for channels, cache, and task queueing shrinks the required external dependencies to just PostgreSQL, while protocol proxying is pushed into separate Go outposts instead of the main Django process.
- Billing & Metering Engine Classic Lago Usage-event ingestion and pricing-expression evaluation are pulled out of the Rails request/response cycle into a dedicated Go service and a shared Rust library, so billing-critical event throughput scales independently of the API that serves the dashboard and public API.
- Local AI Inference Engine AI-agent Ollama Inference performance depends on the accelerator, so the C++ llama.cpp server is built as separate CPU, CUDA, ROCm, and Vulkan variants, with native Go code choosing the right one at runtime, while an independent MLX runner handles Apple Silicon instead of one shared code path.
- API Testing Client Classic Hoppscotch App logic lives in one shared Vue package reused by every client shell, while a native Rust relay and a separate Tauri agent process handle outbound HTTP so desktop and agent users are not limited by browser CORS and sandboxing rules.
- Embedded Backend Classic PocketBase Distributing as a single statically linked binary eliminates microservice operational overhead, running complete production workloads on minimal single-node hardware.
- LLM App Builder AI-agent Dify.ai Agent execution and vector retrieval are split into separate, independently scalable services (a Go sandbox runtime, a FastAPI agent orchestrator, and pluggable vector-store providers) so untrusted tool code and swappable retrieval backends stay out of the core Flask API process.
Often used with Go
AGENTS.md rules and agent skills with Go
go-echo-sqlite/AGENTS.mdGo + Echo + SQLite (Embedded, Self-Hosted Tools)Architecture guidelines for single-binary Go services using the Echo framework, embedded SQLite, and minimal-JS server-rendered UI. intermediatego-postgres-react/AGENTS.mdGo + PostgreSQL (pgx & sqlc) + ReactHigh-throughput systems architecture rules for Go (Golang), pgxpool connection management, sqlc type-safe query generation, and React web dashboards. advanced
Questions about Go
How many production projects use Go?
26 verified production projects in the STACK IT FAST directory use Go, each with a full architecture breakdown.
What is Go most often used with?
Across projects in the directory, Go is most commonly paired with Docker, TypeScript, PostgreSQL.
Is there an AGENTS.md rule or Claude Code skill for Go?
Yes — Go + Echo + SQLite (Embedded, Self-Hosted Tools), Go + PostgreSQL (pgx & sqlc) + React each include a full AGENTS.md, CLAUDE.md, Cursor .mdc rule set and an installable SKILL.md covering Go.