Go libraries ​

Like Chi for web end points. Go API Starter Kit & gorouter seem nice too.

Bun & sqlingo seem like a nice ORMs.

Ristretto & FreeCache are great cache libs.

genqlient is nice GraphQL client. ZenQ is a nice queue lib.

Tutorial on creating go module is great intro. depu is nice for updating dependencies.

mapstructure is nice decoding values from data streams like JSON. zerolo is nice for parsing JSON too. FreeCache is nice caching lib.

Like this error library. conc or workgroup are great for concurrency tasks. script is nice for running shell commands. Log or Logrus are nice for logging.

Go JSON Struct is nice for creating Go types from JSON.

Prometheus client is nice for observability.

Rust + Go is nice guide for calling Rust code from Go although with overhead sadly.

CLI ​

• clap - Lightweight, non intrusive Command Line Argument Parser.
• Clir - Simple and Clear CLI library. Dependency free.
• Bubble Tea - Fun, functional and stateful way to build terminal apps. (Tutorial) (HN) (Template) (Intro to Bubble Tea in Go)
• Bubbles - TUI components for Bubble Tea. (Non Official)
• bubblelister - bubble to list your structs in a bubbletea program.
• Bubble-table - Table component for the Bubble Tea framework.
• teacup - Collection of bubbles and utilities for bubbletea applications.
• Lip Gloss - CSS-like layout library for the terminal for Go.
• Teact - React-like component/layout framework for Charm's Bubbletea.
• bubbleboxer - Way to compose multiple bubbles into one layout.
• BubbleZone - Helper utility for BubbleTea, allowing easy mouse event tracking.
• BubbleTint - Terminal tints for everyone.
• catwalk - Unit test library for Bubbletea TUI models.
• Table - TUI table component for Bubble Tea applications.
• Stickers - Collection of TUI elements, FlexBox and Table at the moment, its build for bubbletea using lipgloss.
• cli - Simple, fast, and fun package for building command line apps in Go.
• Flaggy - Idiomatic Go input parsing with subcommands, positional values, and flags at any position.
• gjson - Get JSON values quickly - JSON parser for Go.
• ishell - Library for creating interactive cli applications.
• progressbar - Basic thread-safe progressbar for Go apps.
• flagga - Extensible Go library for handling program configuration using flags.
• ff - Flags-first package for configuration. (Tweet)
• go-sh - Like python-sh, for easy call shell with golang.
• Docli - Declarative language for describing command-line interfaces.
• uilive - Go library for updating terminal output in realtime.
• gowid - Compositional widgets for terminal user interfaces, written in Go, inspired by urwid.
• go-arg - Structured argument parsing for Go.
• Glamour - Write gorgeous command-line tools.
• termenv - Advanced ANSI style & color support for your terminal applications.
• tui go - UI lib for terminal applications.
• Survey - Library for building interactive prompts.
• GOCUI - Minimalist Go package aimed at creating Console User Interfaces.
• mitchellh/cli - Go library for implementing command-line interfaces.
• Spinner - Simple package to add a spinner / progress indicator to any terminal application.
• Viper - Go configuration with fangs.
• Coral - Friendly Cobra fork with nearly all its features, but only 4 dependencies. (Reddit) (HN)
• Echelon - Hierarchical progress in terminals.
• go-glint - Component-based UI framework specifically targeted towards command-line interfaces.
• PTerm - Modern go module to beautify console output. (Reddit)
• Box CLI Maker - Make Highly Customized Boxes for your CLI.
• Env - Provide default values when fetching environment variables.
• Multi Progress Bar - Go lib for rendering progress bars in terminal applications.
• color - Color package for Go.
• zli - Go library for writing CLI programs. It includes flag parsing, colour escape codes, and various helpful utility functions, and makes testing fairly easy.
• Gosh - Pluggable framework for building command shell programs.
• cmder - Lightweight Go pattern for writing CLIs with subcommands.
• go-sdk - Composable toolbox of libraries to build everything from CLIs to enterprise applications.
• go-feature-flag - Feature flags with no complex system to maintain.
• yacspin - CLI Spinner Go library.
• ASCII Table Writer
• argparse - Argparse for Go. Just because flag sucks.
• goterm - Advanced terminal output in Go.
• Kong - Command-line parser for Go.
• promptkit - Interactive command line prompts with style.
• pty - PTY interface for Go.
• Nice - Highly customizable and lightweight Go CLI app framework.
• Conf - Support for using environmental variables and command line arguments for configuration.
• cli - Expressive Args for Go.
• mow.cli - Versatile library for building CLI applications in Go.
• term - Manages POSIX terminals.
• opts - Building frictionless command-line interfaces.
• Cobra - Commander for modern Go CLI interactions. (Web) (cobrautil) (Cobra Generator)
• oauth2cli - Go package of OAuth 2.0 authorization for command line tools, which allows simple authorization flow for better UX.
• promptui - Interactive prompt for command-line applications.
• acmd - Simple, useful and opinionated CLI package in Go.
• uiprogress - Go library to render progress bars in terminal applications.
• GOCUI - Minimalist Go package aimed at creating Console User Interfaces.
• cli - Package for building command line app with go.
• prompter - Go utility for easy prompting.
• Mango - man-page generator for the Go flag, pflag, and cobra packages.
• Mango Kong - Allows Kong packages to generate man pages using Mango.
• go-spin - Terminal spinner package for Go.
• TCG - Terminal cell graphics library.
• shell - Generate Shell Commands in Go, sprintf Style.
• termbar - Generate terminal charts in Go.
• go-shell - Library to write "shelling out" Go code more shell-like, while remaining idiomatic to Go.
• Qalam - Go library for easy terminal styling.
• Boa - Cobra command styled usage and help component powered by bubbletea.
• console - Go package for dealing with consoles. Light on deps and a simple API.
• Spinner - Simple, configurable, multi-platform terminal spinner.
• subcommands - Permits a Go application to implement subcommands support similar to what is supported by the 'go' tool.
• tablewriter - Simple table using lipgloss and text/tabwriter.
• nfigure - Go struct-tag based configfile and flag parsing.
• go-tty - Simple tty utility.
• shellescape - Escape arbitrary strings for use as command line arguments.
• mainer - Defines types relevant to flag parsing and command entrypoint implementation.
• termlink - Clickable links in the terminal for Go.
• version - Present your CLI version in a classy way.
• goclap - Generate command line argument parsing code from Go comments.
• uitable - Go library to improve readability in terminal apps using tabular data.
• carapace - Command argument completion generator for cobra.
• cliff - Simplest and safest Go library for making CLI tools.
• progrock - Toolkit for streaming, recording, and displaying concurrent progress of inter-dependent vertexes in an execution graph.

Test ​

• Endly - End to end functional test and automation framework.
• Goblin - Minimal and Beautiful Go testing framework.
• is - Professional lightweight testing mini-framework for Go.
• gotest.tools - Collection of packages to augment the go testing package and support common patterns.
• go-cmp - Package for equality of Go values.
• check - Rich testing for the Go language.
• go-mutetesting - Mutation testing for Go source code.
• gotest - Go test with colors.
• Filet - Small temporary file utility for Go testing.
• quicktest - Collection of Go helpers for writing tests.
• go-fuzz - Randomized testing for Go.
• Mockc - Compile-time mock generator for Go.
• Terratest - Makes it easier to write automated tests for your infrastructure code.
• gomonkey - Library to make monkey patching in unit tests easy.
• Gofight - Testing API Handler written in Go.
• Prettybench - Tool for transforming go test's benchmark output a bit to make it nicer for humans.
• goldie - Golden test utility for Go.
• gcassert - Assert your Go code is inlined and bounds-check eliminated.
• autogold - Automatically update your Go tests.
• Gomega - Matcher/assertion library. It is best paired with the Ginkgo BDD test framework.
• go-vcr - Record and replay your HTTP interactions for fast, deterministic and accurate tests.
• Rapid - Go library for property-based testing.
• sqlmock - Mock library implementing sql/driver. Simulate any SQL driver behavior in tests, without needing a real database connection.
• Ginkgo - BDD Testing Framework for Go.
• GoConvey - Go testing in the browser. Integrates with go test. Write behavioral tests in Go.
• Godog - Cucumber BDD framework for Go.
• testlog - Print debugging, but a little bit nicer.
• go-testdeep - Extremely flexible Go deep comparison, extends the go testing package.
• dockertest - Use Docker to run your Go language integration tests against third party services.
• go-test-trace - Go test but it also generates distributed traces.
• Hazana - Build load tests for services (http, gRPC, tcp) by implementing an Attacker.
• Truthy - Provides truthy condition testing with Go generics.
• Moq - Interface mocking tool for go generate.
• testza - Full-featured test framework for Go! Assertions, mocking, input testing, output capturing, and much more.
• Testify - Toolkit with common assertions and mocks that plays nicely with the standard library.
• testify-rules - Ruleguard ruleset bundle for testify.
• httpx - Simple and expressive HTTP testing framework.
• httpmock - Mock library implementing httptest.Server to support HTTP behavioral tests.
• clock - Small library for mocking time in Go.
• gotestfmt - Go test output for humans.
• gomockhandler - Clever and more agile manager of golang/mock.
• gofuzz - Library for populating go objects with random values.
• fzgen - Auto-gen fuzzing wrappers from normal code. Finds buggy call sequences, including data races & deadlocks. Supports rich signature types.
• dockexec - Run Go tests inside a Docker image.
• Loverage - Let your tests describe your program behavior.
• chameleon - Caching reverse proxy for testing written in Go.
• briefpg - Temporary PostgreSQL Instances for Unit Tests.
• go-carpet - Show test coverage in terminal for Go source files.
• Lem - Go test framework for asserting expected escape analysis results & heap allocations.
• Verifiers - Small library for verify async function response.
• Got - Enjoyable Go test framework.
• Be - Generic testing helper for Go.
• qt - Quick helpers for testing Go applications using generics.
• assert - Simple assertion library using Go generics.
• DDD in Go
• cover - Go cover tool for maximum productivity.
• testcase - Opinionated testing framework based on BDD principles.
• gotestlist - List tests in the given Go packages.
• rpctestgen - Test fixture generator for the execution layer JSON-RPC API.
• httpexpect - Concise, declarative, and easy to use end-to-end HTTP and REST API testing for Go.
• Gremlins - Mutation testing tool for Go.
• testpackage - Go linter that encourages you to use a separate test package.
• testtime - time.Now for tests.
• gotests - Automatically generate Go test boilerplate from your source code.
• Threatest - Go framework for testing threat detection end-to-end.
• test - Modern generic testing assertions library for Go.
• golden - Utilities for golden file tests.
• Snapshot - Simple utility to do snapshot testing in Go.
• assert - Common assertions to use with the standard testing package.
• golden - Golden file testing for Go.
• e2e - Robust framework for running complex workload scenarios in isolation, using Go; for integration, e2e tests, benchmarks and more.
• counterfeiter - Tool for generating self-contained, type-safe test doubles in go.
• cupaloy - Simple Go snapshot testing.
• Go Snaps - Jest-like snapshot testing in Go.
• Mocktail - Naive code generator that creates mock implementation using testify.mock.
• ooze - Go Mutation Testing.
• apitest - Simple and extensible behavioral testing library.
• Fake - Fake data generator for Go.
• gobench - Write and plot your benchmark just in Go.
• tparallel - Finds inappropriate usage of t.Parallel() method in your Go test codes.

Web ​

• Chi - Lightweight, idiomatic and composable router for building Go HTTP services.
• Chi CORS
• Trip - Elegant middleware functions for your HTTP clients.
• Flamego - Fantastic modular Go web framework with a slim core but limitless extensibility. (Docs)
• router - Lightning fast HTTP router.
• Nitric - Framework for cloud and serverless apps.
• Minima - Simple and minimal backend framework for go made to scale.
• GoSession - Quick session for net/http in Go.
• Gin - HTTP web framework. Features a Martini-like API with much better performance. (Lightning fast and self contained: How to build a Web App with Gin and SQLite) (Lobsters) (Boilerplate) (Examples)
• Gin-OAuth2 - Middleware for Gin Framework users who also want to use OAuth2.
• gin-gonic/contrib - Collection of middlewares created by the community.
• sessions - Gin middleware for session management.
• Authz - Authorization middleware for Gin.
• gin-jwt - JWT Middleware for Gin Framework.
• gin-timeout - Timeout middleware for Gin.
• gin-swagger - gin middleware to automatically generate RESTful API documentation with Swagger.
• CORS gin - Gin middleware/handler to enable CORS support.
• logger - Gin middleware/handler to logger url path using rs/zerolog.
• RequestID - Request ID middleware for Gin Framework.
• ginpprof - Wrapper for golang web framework gin to use net/http/pprof easily.
• Fizz - Gin wrapper with OpenAPI 3 spec generation.
• Gin Framework Metrics Middleware
• go-fastapi - Library to quickly build APIs.
• Gin Swagger - DRY templates for go-swagger.
• Gin-Metrics - Metrics exporter for Prometheus.
• chizap - Simple zap logging middleware for go-chi.
• Bunrouter - Fast and flexible HTTP router for Go. (Web)
• go-safeweb - Secure-by-default HTTP servers in Go. (Article)
• httplog - Go HTTP request logger with structured logging capabilities.
• fasthttp - Fast HTTP package for Go. Tuned for high performance. Zero memory allocations in hot paths. Up to 10x faster than net/http.
• fasthttp prometheus-middleware - Prometheus middleware for fasthttp, fasthttp/router.
• HTTP2 - HTTP/2 implementation for fasthttp.
• session - Session implementation for fasthttp.
• Router - Router implementation for fasthttp.
• HTTP2 - HTTP/2 implementation for fasthttp.
• fastjsonrpc - Fast JSON-RPC 2.0 implementation for fasthttp server.
• Macaron - High productive and modular web framework in Go.
• Echo - High performance, minimalist Go web framework. (HN) (Starter) (Web App Starter)
• Buffalo
• Gramework - Fast and Reliable Golang Web Framework.
• Vugu - Modern UI library for Go+WebAssembly (experimental).
• Coco - Golang WebAssembly Framework.
• Wasmer - Go library to run WebAssembly binaries at native speed.
• Vecty - Build responsive and dynamic web frontends in Go using WebAssembly, competing with modern web frameworks like React & VueJS.
• Heimdall - Enhanced HTTP client for Go.
• mux - Powerful HTTP router and URL matcher for building Go web servers with.
• go-httpwares - Go HTTP Server Middleware and Client Tripperware.
• Gorsk - Idiomatic Golang Restful Starter Kit.
• Fiber - Expressjs inspired web framework build on Fasthttp. (Examples) (Awesome) (Fiber Boilerplate) (Building microservices in Go with Fiber (2022)) (Docs) (Docs Code) (Fiber OpenTelemetry) (GoFiber Docker Boilerplate) (Storage) (contrib)
• Fiber Swagger - Fiber middleware to automatically generate RESTful API documentation with Swagger 2.0.
• Fiber Swagger - Fiber middleware to automatically generate RESTful API documentation with Swagger.
• REST Layer - API framework heavily inspired by the excellent Python Eve.
• Manners - Polite Go HTTP server that shuts down gracefully.
• httpretty - Package httpretty prints the HTTP requests you make with Go pretty on your terminal.
• Resty - Simple HTTP and REST client library for Go.
• Typhon - Wrapper around Go's net/http to provide safety and convenience.
• Atreugo - High performance and extensible micro web framework. Zero memory allocations in hot paths.
• gearbox - Web framework written in Go with a focus on high performance and memory optimization. (HN)
• Fault - Provides go http middleware that makes it easy to inject faults into your service.
• rest - SendGrid's Golang HTTP Client for calling APIs.
• goproxy - Provides a customizable HTTP proxy library for Go.
• go-retryablehttp - Retryable HTTP client in Go.
• Oxy - Go library with HTTP handlers that enhance HTTP standard library.
• go-limiter - Provides a rate limiter in Go, suitable for use in HTTP servers and distributed workloads.
• cachecontrol - HTTP Caching Parser and Interpretation.
• autotls - Support Let's Encrypt for a Go server application.
• Go-Guardian - Provides a simple, clean, and idiomatic way to create powerful modern API and web authentication.
• gorilla/sessions - Provides cookie and filesystem sessions and infrastructure for custom session backends.
• gorilla/csrf - HTTP middleware library that provides cross-site request forgery (CSRF) protection.
• securecookie - Encodes and decodes authenticated and optionally encrypted cookie values.
• gorilla/handlers - Collection of useful middleware for Go HTTP services & web applications.
• gorilla/schema - Converts structs to and from form values.
• Iris - Fastest HTTP/2 Go Web Framework. (Web)
• Muxie - Modern, fast and light HTTP multiplexer for Go. Fully compatible with the http.Handler interface.
• GoPacket - Provides packet processing capabilities for Go.
• goim - Web server in Go.
• Limiter - Dead simple rate limit middleware for Go.
• dhcp - DHCPv4 and DHCPv6 decoding/encoding library with client and server code, written in Go.
• go-zero - Web and rpc framework that with lots of engineering practices builtin. (Docs) (Examples) (Awesome) (Go-Zero-Lookup)
• libchan - Like Go channels over the network.
• Uhaha - High Availabilty Framework for Happy Data.
• httpcache - Transport for http.Client that will cache responses according to the HTTP RFC.
• daz - Composable HTML components in Go.
• Alice - Painless middleware chaining for Go.
• tinynet - net implementation for Go and TinyGo based on unisockets, targeting both WebAssembly and native platforms.
• go-app - Package to build progressive web apps with Go programming language and WebAssembly. (Docs)
• Revel - High productivity, full-stack web framework for the Go language.
• Live - net/http compatible Phoenix LiveView implementation in Go.
• http-cache - High performance Go HTTP middleware for server-side application layer caching, ideal for REST APIs.
• kcp-go - Production-Grade Reliable-UDP library for Go.
• CNI network plugins
• go-ipset - Go wrapper to the IPtables ipset userspace utility.
• Kite - Micro-service framework in Go.
• safehtml - Provides immutable string-like types that wrap web types such as HTML, JavaScript and CSS.
• HttpRouter - High performance HTTP request router that scales well.
• GoRequest - Simplified HTTP client.
• Go CORS handler - Go net/http configurable handler to handle CORS requests.
• gqlgenc - Go library for building GraphQL client with gqlgen.
• gqlgenc 2 - Fully featured go gql client, powered by codegen.
• canvas - Draw on an HTML 2D canvas in a web browser from a server program using WebSockets.
• Encore - Go framework for building distributed systems. (Web) (Reddit) (HN) (Episode)
• httpx - Fast and multi-purpose HTTP toolkit allows to run multiple probers using retryablehttp library, it is designed to maintain the result reliability with increased threads.
• rek - Easy HTTP client for Go. Inspired by the immortal Requests.
• auth - Painless OAuth authentication middleware.
• Go SSC - HTML render engine concept, that brings frontend-like components experience to the server side with native html/template on steroids.
• golongpoll - Go long polling library. Makes web pub-sub easy via HTTP long-poll servers and clients.
• Vektor - Opinionated production-grade HTTP server framework.
• graphql-go-tools - Tools to write high performance GraphQL applications using Go.
• Lura - Ultra performant API Gateway with middlewares.
• Secure - HTTP middleware for Go that facilitates some quick security wins.
• goql - GraphQL client package written in Go.
• Glue - Robust Go and JavaScript Socket Library.
• gock - HTTP traffic mocking and testing made easy in Go.
• YoMo - Streaming-Serverless Framework for Low-latency Edge Computing applications, running atop QUIC protocol, engaging 5G technology.
• httparty - Go HTTP library.
• jwt - Go implementation of JSON Web Tokens (JWT).
• carbonapi - Implementation of graphite API (graphite-web) in Go.
• fast-graphql - Experimental GraphQL implementation with Go. This repo focuses on improve GraphQL Parse and Resolve speed to a new level.
• health-go - Library to provide basic healthcheck functionality to Go applications.
• Kratos - Go framework for microservices.
• cap - Collection of authentication Go packages related to OIDC, JWKs and Distributed Claims.
• letgo - Open-source, high-performance web framework for the Go programming language.
• api2 - Go library to make HTTP API clients and servers.
• httprate - net/http rate limiter middleware.
• elk - Aims to extend the awesome entgo.io code generator to generate a fully-functional HTTP API on a defined set of entities.
• simplesessions - Go session library that is completely agnostic of HTTP libraries and frameworks, backend stores, and even cookie jars. (Article)
• Coraza Web Application Firewall - Go modsecurity compatible web application firewall library. (Web)
• Netpoll - High-performance non-blocking I/O networking framework, which focused on RPC scenarios, developed by ByteDance.
• Kitex - High-performance and strong-extensibility Go RPC framework that helps developers build microservices.
• go-sse - Lightweight, fully spec-compliant HTML5 server-sent events library.
• go-restful - Package for building REST-style Web Services using Go.
• reliable - Reliability layer for UDP connections in Go.
• monte - Bare minimum for high performance, fully-encrypted bidirectional RPC over TCP in Go with zero memory allocations.
• ns-x - Easy-to-use, flexible network simulator library for Go.
• ratelimiter - Concurrent rate limiter library for Go based on Sliding-Window rate limiter algorithm.
• rehttp - Implements a Go HTTP transport that handles retries.
• noctx - Finds sending http request without context.Context.
• Semaphore - Create advanced and high performing data flows and expose them through endpoints over multiple protocols such as HTTP, GraphQL, and gRPC.
• Commander - Go library for writing event-driven applications. Enabling event sourcing, RPC over messages, SAGA's, bidirectional streaming and more.
• socket - Provides a low-level network connection type which integrates with Go's runtime network poller to provide asynchronous I/O and deadline support.
• Kyoto - Build Front End with Go. (Web) (HN)
• Retry - Go library for retrying with configurable backoffs.
• h2conn - HTTP2 client-server full-duplex connection.
• go-sockaddr - IP Address/UNIX Socket convenience functions.
• go-webview2 - WebView2 bindings for pure Go, without CGo, based on the webview/webview bindings.
• Redeo - High-performance framework for building redis-protocol compatible TCP servers/services.
• httpin - HTTP Input for Go - Decode an HTTP request into a custom struct.
• Adaptive Throttler - Thread-safe throttler library.
• IndieAuth Helpers
• R2 - Minimalist HTTP request routing helper for Go.
• qtalk-go - Versatile RPC and IO stream based IPC stack for Go.
• hedgedhttp - Hedged HTTP client which helps to reduce tail latency at scale.
• gomponents - View components in pure Go, that render to HTML 5. (Web)
• Gzip Handler - Go middleware to gzip HTTP responses.
• microblob - Serve millions of JSON documents via HTTP.
• Requests - HTTP requests for Gophers. (Why I wrote my own Go HTTP client) (Reddit)
• EasyRaft - Easy to use Raft library to make your app distributed, highly available and fault-tolerant.
• Truss - Helps you build go-kit microservices without having to worry about writing or maintaining boilerplate code.
• ratelimit - Efficient token-bucket-based rate limiter package.
• Flow - Delightfully simple, readable, and tiny HTTP router for Go web applications. (Article)
• lossy - Go package to simulate bandwidth, latency and packet loss for net.PacketConn and net.Conn interfaces.
• net - Supplementary Go networking libraries.
• Swag - Helper functions for go-openapi and go-swagger projects.
• Go JOSE - Implementation of JOSE standards (JWE, JWS, JWT) in Go.
• gorouter - Go Server/API micro framework, HTTP request router, multiplexer, mux.
• graceful - Best practice http server set up that supports graceful shutdown.
• Req - Simplified Go HTTP client library with Black Magic, Less code and More efficiency.
• Turbo-go - Build hotwire apps using go.
• Huma - Modern, simple, fast & opinionated REST API framework for Go with batteries included.
• gmux - Go library for simultaneously serving net/http and gRPC requests on a single port.
• pester - Go http calls with retries and backoff.
• httperr - func(w http.ResponseWriter, r *http.Request) error.
• cleanhttp - Functions for accessing "clean" Go http.Client values.
• web - Basic web site serving framework.
• Martian Proxy - Library for building custom HTTP/S proxies.
• go-hit - HTTP integration test framework.
• srtgo - Go bindings for SRT (Secure Reliable Transport), the open source transport technology that optimizes streaming performance across unpredictable networks.
• iploc - Fastest IP To Country Library.
• ratelimit - Go blocking leaky-bucket rate limit implementation.
• go-http-metrics - Measure HTTP metrics in different metric formats and Go HTTP framework/libs.
• go-ipam - Module to handle IP address management. It can operate on networks, prefixes and IPs.
• Extemplate - Wrapper package for Go's template/html to allow for easy file-based template inheritance.
• echo-swagger - Echo middleware to automatically generate RESTful API documentation with Swagger 2.0.
• Go Seamless Restart - Seamless restart / zero-downtime deploy for Go servers.
• GoLobby Router - Lightweight yet powerful HTTP router for Go.
• netns - Simple network namespace handling for go.
• fastudp - Fast implementation of UDP.
• go-redoc - Embedded OpenAPI/Swagger documentation ui for Go using ReDoc.
• pub0sub - Fast, Lightweight Pub/Sub over TCP, QUIC - powered by Async I/O.
• go-libp2p-webtransport
• g8 - Go library for protecting your HTTP handlers.
• gldap - Build LDAP services w/ Go.
• Bud - Full stack Go Framework for Prolific Web Developers. (HN)
• Health - Simple and flexible health check library for Go.
• Hertz - High-performance and strong-extensibility Go HTTP framework that helps developers build microservices.
• GO JWT Middleware - Middleware for Go Programming Language to check for JWTs on HTTP requests.
• go.pkt - Go libraries for capturing, injecting, filtering, encoding and decoding network packets.
• Ghost - Build REST APIs from structs using Generics.
• fir - Go library to build reactive apps.
• Copper - Go toolkit complete with everything you need to build web apps. (HN) (Web)
• dead-letter-queue - Tiny go package to manage HTTP requests with dead letter management/retry. Based on go-redis.
• Moonshot - Boilerplate Go library for quickly setting up web backend.
• KaGo - High-level web framework, that encourages rapid development and clean, pragmatic design.
• Medium - Experimental Go code for writing web apps.
• httpsnoop - Provides an easy way to capture http related metrics (i.e. response time, bytes written, and http status code) from your application's http.Handlers.
• Statigz - Serves pre-compressed embedded files with http in Go.
• retry - Simple utils for exponential back off.
• go-http - Go HTTP Clients/Servers and Alternative Networking.
• gofetch - Lightweight and productive http client for Go.
• TTL - Time To Live Cache Implementation for Go.
• azugo - Opinionated Go web framework based on fasthttp and inspired by go-chi.
• go-vhost - HTTP/TLS hostname multiplexing library for Go.
• getty - Netty like asynchronous network I/O library based on tcp/udp/websocket; a bidirectional RPC framework based on JSON/Protobuf; a microservice framework based on zookeeper/etcd.
• go-syslog - Syslog server library for go.
• Gain - High-performance io_uring networking framework written entirely in Go. (Article)
• Pushup - Page-oriented web framework for Go. (Web) (HN) (Lobsters)
• genhapi - Opinionated tool for generating request-handler boilerplate for Go.
• GoLive - Library for building LiveViews in Go.
• uRouter - HTTP & WebSocket router library for Go.
• fcors - Fearless CORS - a principled CORS middleware library for Go.
• go-connections - Utility package to work with network connections.
• assetserver - Go file server for web assets.
• gurl - Combinator library for network I/O.
• WebGo - Minimalistic router for Go to build web applications (server side) with no 3rd party dependencies.
• htmlquery - XPath query package for HTML, lets you extract data or evaluate from HTML documents by an XPath expression.
• Goravel - Go framework for web artisans. Tribute to Laravel.
• QOR5 - Go library to build web applications.
• Tokenizer - HTTP proxy that injects 3rd part credentials into requests.
• go-orb - Micro services framework.
• Request Baskets - HTTP requests collector to test webhooks, notifications, REST clients and more.
• goev - Lightweight, concise i/o event demultiplexer implementation in Go. (Reddit)

GraphQL ​

• gqlparser - Port of the parser from graphql-js into Go.
• genqlient - Truly type-safe Go GraphQL client. (Article) (Article)
• GQLGen - Library for quickly creating strictly typed graphql servers in golang. (Docs) (GQLGen PG TODO Example) (Demo Code)
• gq - Library to help build GraphQL server in Go.
• GGql - GraphQL implementation for Go.
• Tutone - Generate Go types from GraphQL schema introspection.
• go-graphql - Different approach to making graphql servers in Go.
• fluentgraphql - Fluent GraphQL client library in Go.
• graphql - GraphQL client implementation.

Flag parsing ​

• go-flags - Provides an extensive command line option parser.

Search ​

• go-sonic - Sonic driver written in Go.

Auth ​

• Goth - Multi-Provider Authentication for Go. Simple, clean, and idiomatic way to write authentication packages for Go web applications.
• go-srp - SRP-6a implementation in Go.
• verifier - Go JWT token verifier with storage.
• otp - Go implementation of the HOTP and TOTP algorithms.
• oauth2dev - Go package of OAuth 2.0 Device Authorization Grant.
• WebAuthn - Webauthn/FIDO2 library in Go.
• simplejwt - Simple JWT package.

DB ​

• BQB - Lightweight and easy to use query builder.
• KissSQL - Simple and Powerful Go SQL Library.
• Kvass - Personal key-value store. (HN)
• BetterCache - Modern Caching System with Lightning Fast Full Text Search. (Reddit)
• sql - Pure Go SQL parser.
• Bob - SQL Query Builder for Go.
• go-sqlbuilder - Flexible and powerful SQL string builder library plus a zero-config ORM.
• pgx - PostgreSQL driver and toolkit for Go.
• sq - Type-safe data mapper and query builder for Go. (Lobsters)
• sqlingo - Lightweight DSL & ORM which helps you to write SQL in Go.
• ArcticDB - Embeddable columnar database written in Go. Features semi-structured schemas, and uses Apache Parquet for storage, and Apache Arrow at query time. (Intro) (Tweet) (HN) (Lobsters)
• sniper - Simple and efficient thread-safe key/value store for Go.
• Bun - Simple and performant ORM for SQL. (Web)
• GORM SQLite - Pure-go (without cgo) implementation of SQLite driver for GORM.
• BuntDB - Embeddable, in-memory key/value database for Go with custom indexing and geospatial support.
• hashmap - Efficient hashmap implementation in Go.
• reform - Better ORM for Go and database/sql.
• db - Productive data access layer for Go.
• GORM - Fantastic ORM library for Golang, aims to be developer friendly.. (Web)
• DBResolver - Multiple databases, read-write splitting FOR GORM.
• GORM/GEN - Safer ORM base on GORM.
• pg - Golang ORM with focus on PostgreSQL features and performance.
• zoom - Blazing-fast datastore and querying engine for Go built on Redis.
• bolter - View BoltDB file in your terminal.
• pg_query_go - Go library to parse and normalize SQL queries using the PostgreSQL query parser.
• SQLBoiler - Tool to generate a Go ORM tailored to your database schema. (Twitter)
• gqlgen-sqlboiler - This is a plugin for gqlgen to generate converts + filter queries and resolvers for sqlboiler.
• sqlmw - Provides an absurdly simple API that allows a caller to wrap a database/sql driver with middleware.
• go-mysql - Pure go library to handle MySQL network protocol and replication.
• Redcon - Custom Redis server framework for Go that is fast and simple to use.
• Go SQLite3 driver
• txdb - Immutable transaction isolated sql driver for golang.
• MySQL Compatible SQL Parser
• athenadriver - Fully-featured AWS Athena database driver (plus a utility tool).
• bitcask - High performance Key/Value store written in Go with a predictable read/write performance and high throughput.
• Storm - Simple and powerful toolkit for BoltDB.
• taskq - Golang asynchronous task/job queue with Redis, SQS, IronMQ, and in-memory backends.
• Carta - SQL data mapper for Go.
• QLBridge - Go SQL Runtime Engine.
• dbq - Zero boilerplate database operations for Go.
• sql-migrate - SQL Schema migration tool for Go. Based on gorp and goose.
• Pop - Makes it easy to do CRUD operations, run migrations, and build/execute queries.
• go-sqlcipher - Self-contained Go sqlite3 driver with an AES-256 encrypted sqlite3 database.
• Glow - Easy-to-use distributed computation system written in Go, similar to Hadoop Map Reduce, Spark, Flink, Storm.
• Stow - Simple object persistence with boltdb.
• go-structured-query - Code-generated, type safe query builder and struct mapper for Go.
• remember-go - Cache Slow Database Queries.
• RamSQL - In-memory SQL engine in Go sql/driver for testing purpose.
• goqu - Expressive SQL builder and executor.
• goyesql - Go + Yesql.
• go-pg-migrations - Go package to help write migrations with go-pg/pg.
• gosql - Early PostgreSQL implementation in Go.
• go-storage - Application-oriented unified storage layer for Go. (Docs)
• Cloud SQL Proxy - Allows a user with the appropriate permissions to connect to a Second Generation Cloud SQL database without having to deal with IP whitelisting or SSL certificates manually.
• SQLDB-Logger - Logger for Go SQL database driver without modify existing *sql.DB stdlib usage.
• Kallax - PostgreSQL typesafe ORM for the Go language.
• Gonudb - Append-only key/value datastore written in Go.
• go-memdb - Go in-memory database built on immutable radix trees.
• tailetc - total-memory-cache etcd v3 client.
• query - Simple PostgreSQL query builder for Go.
• postgresql-parser - PostgreSQL style Parser splitted from CockroachDB.
• pggen - Generate type-safe Go from any Postgres query. If Postgres can run the query, pggen can generate code for it.
• Squirrel - Fluent SQL generator for Go.
• Bob - SQL Query Builder. Extension of Squirrel with functionability like Knex.
• Litestream as Library - Example repository for embedding Litestream in a Go application.
• go-sqlite - Low-level Go interface to SQLite 3.
• go-sqlite3 - SQLite driver for go using database/sql. (Article)
• go-sqlite3-stdlib - Standard library for mattn/go-sqlite3 including best-effort date parsing, url parsing, math/string functions, and stats aggregation functions.
• tpg - Insanely tiny Postgres library for Go.
• dburl - Provides a standard, URL style mechanism for parsing and opening SQL database connection strings for Go.
• Loukoum - Simple SQL Query Builder.
• tstorage - Fast time-series data storage library.
• Kiwi - Minimalistic in-memory key value store. (Web)
• gosql - Very simple ORM library for Go.
• Scan - Scan database/sql rows directly to structs, slices, and primitive types.
• go-sqlite3-js - Go SQL driver for sqlite3 in browser (sql.js) from go-wasm.
• Authority - Role Based Access Control (RBAC) with database persistence.
• pggen - Database first code generator focused on postgres. (Article)
• gosq - Parsing engine for a simplicity-focused, template-based SQL query builder for Go.
• pgtype - Implements Go types for over 70 PostgreSQL types.
• scany - Library for scanning data from a database into Go structs and more.
• pglock - PostgreSQL Lock Client for Go.
• pgxmock - Mock library implementing pgx - PostgreSQL Driver and Toolkit.
• Gendry - Go library that helps you operate database.
• otelsql - OpenTelemetry instrumentation for database/sql.
• CockroachDB Go - Helpers for CockroachDB users writing in Go.
• go-sstables - Go library for protobuf compatible sstables, a skiplist, a recordio format and other database building blocks like a write-ahead log.
• sqlcommenter
• sqlhooks - Attach hooks to any database/sql driver.
• vitess-sqlparser - Simply SQL Parser for Go (powered by vitess and TiDB).
• Authzed Go
• Datastore Wrapper - AppEngine | Cloud Datastore wrapper for Go.
• moss - Simple, fast, ordered, persistable, key-val storage library for Go.
• Chestnut - Encrypted storage for Go.
• spindle - Distributed locking library built on top of Cloud Spanner and TrueTime.
• Bokchoy - Simple job queues for Go backed by Redis.
• Migrate - Simple database migration tool using an sql.DB connection and fs.FS for the migration source.
• ch - TCP ClickHouse client in Go.
• kra - Database access helper library.
• go-sqlsmith - Go version of SQLsmith.
• go-sqlite
• pqt - Postgres schema definition, sql/go, code generation package.
• Prana - Go Database Management and Code Generation.
• ORM - Facilitates execution of SQL scripts generated by prana.
• squirrel - Cache backed by SQLite3.
• Morph - Database migration tool that helps you to apply your migrations.
• gosql - Easy ORM library for Go.
• ql - Pure Go embedded SQL database. (HN)
• Tables-to-Go - Convert your database tables to structs easily.
• metricsql - Standalone PromQL and MetricsQL parser.
• gen - Converts a database into gorm structs and RESTful API.
• Scribble - Tiny JSON database in Go.
• godb - Go SQL query builder and struct mapper.
• sqlf - Generate parameterized SQL statements in Go, sprintf Style.
• grocksdb - RocksDB wrapper for Go.
• mssqlx - Database client library, proxy for any master slave, master master structures. Lightweight, performant and auto balancing in mind.
• BadgerDB - Fast Key-Value DB in Go.
• pgtalk - More type safe SQL query building and execution using Go code generated (pgtalk-gen) from PostgreSQL table definitions.
• gls - Goroutine local storage.
• zdb - Nice API to interact with SQL databases in Go.
• FlashDB - Embeddable, in-memory key/value database in Go (with Redis like commands). (Writing a simple in-memory key-value Database in Go)
• zizou - In memory cache implementation with high concurrency.
• go-zetasql - Go bindings for ZetaSQL. ZetaSQL can parse all queries related to Cloud Spanner and BigQuery.
• Permify Gorm - Associate users with roles and permissions.
• Goven - Go library that allows you to have a drop-in query language for your database schema. (Building Goven)
• Margaret - Flume-like persisted append-only log implementation.
• RedisAI Go Client
• GocqlX - All-In-One: CQL query builder, ORM and migration tool.
• Memory Cache - Zero-dependency cache library for storing data in memory with generics.
• GoMybatis - Go ORM Library. Powerful Features like transaction nesting, Optimistic Lock, Logical deletion and more.
• Ristretto - Fast, concurrent cache library built with a focus on performance and correctness.
• Cloud SQL Go Connector - Cloud SQL connector designed for use with the Go language.
• agecache - LRU cache with support for max age.
• chartmuseum/storage - Go library providing a common interface for working across multiple storage backends.
• go-blockservice - Seamless interface to both local and remote storage backends.
• GORM Data Types
• sqlite - CGo-free port of SQLite. (HN)
• Golobby ORM - Lightweight yet powerful, fast, customizable, type-safe object-relational mapper for Go.
• lockfree - Go lock-free concurrent Hashmap.
• satomic - Go package that makes managing nested SQL transactions/savepoints easier.
• gorocksdb - Go wrapper for RocksDB.
• gokv - Simple key-value store abstraction and implementations for Go (Redis, Consul, etcd, bbolt, BadgerDB, LevelDB, Memcached, DynamoDB, S3, PostgreSQL, MongoDB, CockroachDB and many more).
• pgproto3 - Encoder and decoder of the PostgreSQL wire protocol version 3. Can be used as a foundation for PostgreSQL drivers, proxies, mock servers, load balancers and more.
• gocache - High performance and lightweight in-memory cache library with LRU and FIFO support as well as memory-usage-based-eviction.
• libkv - Distributed key/value store abstraction library.
• DALI - Thin layer over Go's database/sql.
• Go ORM Benchmarks - Advanced benchmarks for +10 Go ORMs.
• go-ceph - Go bindings for Ceph APIs.
• sqlf - Fast SQL query builder for Go.
• DBX - Tool to generate database schemas and code to operate with it. Currently generates Go bindings to Postgres and/or SQLite.
• qder - Query builder for Go.
• go-sqlla - Type safe, reflect free, generative SQL Builder.
• Tickler - Enqueue and process the jobs in the background.
• Cache - Generic cache use and cache manage.
• dbump - Go database schema migrator library.
• dsunit - Datastore Testibility.
• Instorage - Simple, easy to use database for faster development of small projects and MVPs in Go. Uses Badger as a storage.
• cache - Concurrency safe, mostly lock-free, singleflight request collapsing generic cache with support for stale values.
• superbasic - Compiles expressions and value-lists into SQL strings and thus offers an alternative to conventional query builders.
• TiKV Go Client
• HaxMap - Fastest and most memory efficient Go concurrent hashmap.
• Storage - Go package for abstracting local, in-memory, and remote (Google Cloud Storage/S3) file systems.
• Genna - Model generator for go-pg package.
• objstore - Go module providing unified interface and efficient clients to work with various object storage providers until like GCS, S3, Azure, SWIFT, COS and more.
• Google Spanner SpanSQL Query Builder
• approx-lru - Go LRU cache.
• ScyllaDB Go Driver (Article) (HN)
• libschema - Way for Go libraries to manage their own database migrations.
• redis - Redis client for Go.
• go-dqlite - Go package, containing bindings for the dqlite C library and a pure-Go client for the dqlite wire protocol.
• Lazycache - Simple thread safe in-memory LRU cache.
• YaDAL - Accessing S3, POSIX in the same way. Deeply inspired by Databend's OpenDAL.
• Ghostly - Simple, lightweight, and fast full-stack framework for Go. (HN)
• go-sqlite - Pure-Go SQLite driver for Go (SQLite embedded).
• dblens - HTTP handler for database browsing.
• expirable-cache - Expirable Go LRC\LRU cache without goroutines.
• Proteus - Simple tool for generating an application's data access layer.
• pgeo - Geometric Types for Postgres.
• BarrelDB - Disk based key-value store based on Bitcask.
• DBML Go - DBML parser and tools for Go.
• catena - Storage engine for time series data.
• zipcache - In-memory compressed cache.
• Neoq - Background job processing built on Postgres for Go. (Lobsters)
• otelsql - OpenTelemetry SQL database driver wrapper for Go.
• scan - Scan provides the ability to to scan SQL rows directly to any defined structure.
• go-db - Wrapper over pgx with better transaction API.
• GreptimeDB Go Client
• go-sqlite3 - Go bindings to SQLite using Wazero.
• migrator - Dead simple Go database migration library.
• go-tinylfu - TinyLFU cache admission policy.
• imcache - Generic in-memory cache Go library.
• Go SDK for libSQL
• FreeLRU - GC-less, fast and generic LRU hashmap library for Go.
• XQL - Type-safe query statements in Go.
• sqlds - Package that assists writing SQL-driven datasources.
• Geche - Generic cache implementations in Go focused on simplicity.
• DLFUCache - Decaying Least Frequently Used Cache implementation.
• Gorm Caches - Plugin using database request reductions (easier), and response caching mechanism provide you an easy way to optimize database performance.
• GORM SQLite Driver
• pgconn - Low-level PostgreSQL database driver.
• sqlitestore - blob.Store implementation on SQLite3.
• pg-schema-diff - Go library for diffing Postgres schemas and generating SQL migrations.
• LiteFS Go - Go library for interacting with LiteFS.
• pgfs - Go library that implements fs.FS on top of Postgres's large objects API.
• OpenTelemetry instrumentations for Go
• schema - Go package providing access to database schema metadata, for database/sql drivers.
• kataras/pg - Go library that simplifies PostgreSQL database interaction with struct-based entities, schema management, and repository pattern.
• pgmq-go - Go client for Postgres Message Queue (PGMQ).
• REM - Retro Go ORM.

ML ​

• go-deep - Feed forward/backpropagation neural network implementation.
• gobrain - Neural Networks written in go.
• wann - Weight Agnostic Neural Networks in Go.
• spaGO - Supports relevant neural network architectures in natural language processing tasks.
• go-featureprocessing - Ultra-fast and simple feature processing in Go with functionality matching sklearn.
• onnx-go - Go Interface to Open Neural Network Exchange (ONNX).
• Mab - Library for multi-armed bandit selection strategies, including efficient deterministic implementations of Thompson sampling and epsilon-greedy.
• mu8 - Genetic algorithm for machine learning in Go.
• go-face - Face recognition with Go.
• Nune - Tensor based numerical engine.
• Cybertron - Go package that provides a simple and easy-to-use interface for cutting-edge NLP.
• CNNs - Convolutional Neural Networks in Go.
• GoMLX - Accelerated ML Libraries for Go.

Graphics ​

• pbr - Implements Physically-Based Rendering via a unidirectional CPU-only Monte Carlo path tracer.
• orb - Types and utilities for working with 2d geometry in Golang.
• Canvas - Cairo in Go: vector to SVG, PDF, EPS, raster, HTML Canvas, etc.
• gfx - Convenience package for dealing with graphics in my pixel drawing experiments.
• gg - 2D rendering in Go with a simple API.
• goworld - OpenGL-based 3D Engine.
• Tetra3D - 3D software renderer written in Go and Ebiten and made for games.
• go-astilectron - Build cross platform GUI apps with GO and HTML/JS/CSS (powered by Electron).
• go-sciter - Go bindings of Sciter: the Embeddable HTML/CSS/script engine for modern UI development.
• bimg - Go package for fast high-level image processing powered by libvips C library.
• twodeeparticles - Engine-agnostic 2D particle system simulator for Go.
• polyred - 3D Graphics in Go.
• Resolv - Simple 2D Go collision detection and resolution library for games.

WASM ​

• gocalstorage - Go bindings for the JavaScript Storage APIs, using WASM.
• vert - WebAssembly interop between Go and JS values.
• WASM-Fetch - Web Assembly fetch wrapper that avoids importing net/http.
• wasmexec - Runtime-agnostic implementation of Go's wasm_exec.js in Go.
• Waggy - Dead simple, easy-to-use library for writing WAGI (Web Assembly Gateway Interface) API handlers in Go.
• tinyjson - Fast and easy way to marshal/unmarshal Go structs to/from JSON to use with TinyGo.
• wasmbrowsertest - Run Go WASM tests easily in your browser.
• nottinygc - Higher-performance allocator for TinyGo WASI apps.
• go-indexeddb - IndexedDB driver with bindings for Go code compiled to WebAssembly.
• WASI - Go implementation of the WebAssembly System Interface (WASI).

GUI ​

• Gio - Implements portable immediate mode GUI programs in Go. (Code) (HN) (Let’s build a Gui with Gio) (Tutorials)
• ui - Platform-native GUI library for Go.
• Nucular - GUI toolkit for go.
• Gorough - Create graphics with a hand-drawn, sketchy, appearance. Based on Rough.js.
• giocanvas - Canvas API built with Gio.

macOS ​

• MacDriver - Native Mac APIs for Go. (HN)
• apfs - Package apfs implements an Apple File System(apfs) bindings for Go.
• go-macho - Implements access to and creation of Mach-O object files.

Math ​

• linalg - Fast and easy-to-use package for Linear Algebra calculations with matrices and vectors.
• Nune - High-performance numerical engine based on generic tensors.
• kmeans - k-means clustering algorithm implementation written in Go.
• clusters - Data structs and algorithms for clustering data observations and basic computations in n-dimensional spaces.
• Autodiff - Numerical library for Go. Supports automatic differentiation.
• go3d - Performance oriented vector and matrix math package for 2D and 3D graphics.
• go-moremath - Assortment of more specialized math routines for Go.
• gambas - Data analysis tool for Go. Similar to the famous Python library pandas.
• rand - Fast, high quality alternative to math/rand and golang.org/x/exp/rand.
• Maths - Includes mathematical functions not defined in the standard Go math package.
• ease - Easing Functions in Go.
• percent - Simple library for calculate percentages.
• vector - Better way to write vector math in Go.
• go-fraction - Go library for working with fractions.
• MathGL - Pure Go 3D math library.
• factorlib - Library for factoring big integers in Go.

Biology ​

• biostuff - Go packages for handling biological data.

Docker ​

• go-containerregistry - Go library and CLIs for working with container registries.

Crypto ​

• Go Cryptography - Go supplementary cryptography libraries.
• ristretto255 - Implements ristretto255, a fast prime-order group.
• Secure IO - Go implementation of the Data At Rest Encryption (DARE) format.
• Secure Bytes - Take any Go data type, serialize it to JSON or GOB and encrypt it with AES.
• ec3 - Elliptic Curve Cryptography Compiler.
• XXH3 - XXH3 algorithm in Go.
• smt - Go library that implements a Sparse Merkle tree for a key-value map.
• tss-lib - Multi-Party Threshold Signature Scheme.
• multi-party-sig - Implementation of protocols for threshold signatures.
• pkcs7 - Implements a subset of PKCS#7/Crytpographic Message Syntax.
• xsum - More useful checksums using Merkle Trees.
• go-tfhe - Go implementation of TFHE Encrypted Computation Scheme.
• BLS12-381 - High Speed BLS12-381 Implementation in Go.
• Disco - Protocol to encrypt communications and a cryptographic library based on Disco.
• libhydrogen-go - Go wrapper for libhydrogen.
• GopenPGP - High-level OpenPGP library.
• Go-wolfSSL - Go wrapper for wolfSSL lightweight TLS library and wolfCrypt cryptography library.
• Reed-Solomon - Reed-Solomon Erasure Coding in Go.
• sftp - SFTP support for the go.crypto/ssh package.
• libsignalgo - Go wrapper for the libsignal library.
• encrypted-stream - Go library that transforms any net.Conn or io.ReadWriter stream to an encrypted and/or authenticated stream.
• xxhash - Native implementation of the excellent XXHash hashing algorithm.
• curve25519-voi - High-performance Curve25519/ristretto255 for Go.
• Whisper - Wraps an io.ReadWriter in a secure tunnel using modern elliptic-curve cryptography. (HN)
• keygen - Deterministic key generation for Go.
• go-iden3-crypto - Go implementation of some cryptographic primitives (that fit inside the SNARK field).

Linux ​

• go-criu - Go Bindings for CRIU.
• rtnetlink - Provides low-level access to the Linux rtnetlink API.
• go-fuse - Go native bindings for the FUSE kernel module.
• automaxprocs - Automatically set GOMAXPROCS to match Linux container CPU quota.
• gobpf - Go bindings for creating BPF programs.
• go-eBPF - Pure Go library that provides utilities for loading, compiling, and debugging eBPF programs.
• zerocopy - Zero-copy I/O primitives and pipelines for Go. Linux-specific.
• nftables - Manipulates Linux nftables (the iptables successor).
• libbpfgo - Go library for working with Linux's eBPF.
• Sysinfo - Go library providing Linux OS / kernel / hardware system information.
• tenus - Allows you to configure and manage Linux network devices programmatically.
• CAN Go - Makes use of the Linux SocketCAN abstraction for CAN communication.
• ethtool - Simple access to the Linux SIOCETHTOOL ioctl operations.
• Go eBPF - Library to work with eBPF programs from Go.
• go-uring - Linux io_uring for Go.
• libseccomp-go - Easy to use, platform independent, interface to the Linux Kernel's syscall filtering mechanism.
• go-evdev - Go support for the Linux evdev interface.
• Go Landlock - Go library for the Linux Landlock sandboxing feature.
• ZSocket - Zero-copy sockets for Linux in Go.
• Gonso - Library to do safe Linux namespace manipulation in Go.
• go-perf - Go packages and tools for Linux perf.
• debpkg - Go library to create Debian Linux packages.
• go-iptables - Go bindings for iptables utility.
• golang-evdev - Go bindings for the linux input subsystem.
• gpiod - Native Go library for Linux GPIO.
• wl - Pure Go Wayland protocol implementation.

Apple ​

• go-apfs - APFS parser written in pure Go.

Error ​

• Simplerr - Advanced Go error handling, made simple.
• Emperror - Takes care of all errors personally.
• Errors - Drop-in replacement for Go errors, with some added sugar! Error handling in Go made easy with codes, messages and more.
• Errors - Drop-in replacement for Go errors, with some added sugar! Unwrap user-friendly messages, HTTP status code, easy wrapping with multiple error types.
• errors - Provides an easy way to annotate errors without losing the original error context.
• panicwrap - Go library for catching and handling panics in Go applications.
• multierr - Merges multiple errors into a single error value in idiomatic Go way.
• multierr - Combine one or more Go errors together.
• fail - Better error handling solution especially for application servers.
• errorx - Comprehensive error handling library for Go.
• Stacktrace - Stack traces for Go errors.
• errors - Go errors with network portability.
• Errors - Drop-in replacement for the standard library errors package and github.com/pkg/errors.
• semgroup - Provides synchronization and error propagation, for groups of goroutines working on subtasks of a common task.
• errors - Simple error wrapping package that automatically adds source locations to errors.
• Benchmarking Go errors
• go-serum - Implementation of the Serum Errors Specification for use in Go development.
• errors - Clear go error wrapping with caller.
• failpoint - Fail points are used to add code points where errors may be injected in a user controlled fashion.
• Go Result - Simple result type in Go 1.18.
• try - Simplified error handling in Go.
• oerrs - Adds an ErrorList with optional stack traces.
• Errors - Better domain errors with Go.
• merry - Go errors with stacktrace and context.
• Errors - Create constant sentinel errors with errors.Is support.
• go-xerrors - Idiomatic and lightweight package that provides a set of functions to make working with errors easier. (Reddit)
• Fault - Go errors but structured and composable. Fault provides an extensible yet ergonomic mechanism for wrapping errors. (Reddit)
• werr - Wraps errors with a stack trace.
• err2 - Automatic error propagation package.
• Trace - Package for error handling and error reporting.
• Blunder - Modern golang error handling package powered by GPT-3.
• html2text - Simple Go package to convert HTML to plain text.
• elk - Extensive error utility package with the focus on ease of use.

Other ​

• go-funk - Modern Go utility library which provides helpers (map, find, contains, filter, ...).
• Argum - Parse incoming arguments in to structure.
• Go prompt
• The Joy compiler
• Graphql - Simple low-level GraphQL HTTP client.
• ws - WebSocket implementation in Go.
• GraphQL Go - Implementation of GraphQL.
• Mock - Mocking framework.
• jstream - Streaming JSON parser.
• cmux - Connection multiplexer for GoLang: serve different services on the same port.
• go-cloud - Library and tools for open cloud development in Go.
• go-jsonschema - Tool to generate Go data types from JSON Schema definitions.
• go-write - Package write provides a way to atomically create or replace a file or symbolic link.
• go-metrics - Go port of Coda Hale's Metrics library.
• lorca - Build cross-platform modern desktop apps in Go + HTML5.
• gocc - Parser / Scanner Generator.
• k8s - Simple Kubernetes Go client.
• go-plist - Pure Go Apple Property List transcoder.
• gomail - Best way to send emails in Go.
• validator - Implements variable validations.
• go-jira - Go client library for Atlassian JIRA.
• go-redis - Type-safe Redis client for Golang.
• esc - Simple file embedder for Go.
• certmagic - Automatic HTTPS for any Go program: fully-managed TLS certificate issuance and renewal.
• gogrep - Search for Go code using syntax trees.
• llvm - Library for interacting with LLVM IR in pure Go.
• ssh - Easy SSH servers in Golang.
• retry - Functional mechanism based on channels to perform actions repetitively until successful.
• ytdl - YouTube download library and CLI written in Go.
• go-cty - Type system for dynamic values in Go applications.
• avo - Generate x86 Assembly with Go.
• govaluate - Arbitrary expression evaluation for golang.
• Stats - Well tested and comprehensive Golang statistics library package with no dependencies.
• go-travis - Go library for accessing the Travis CI API V3.
• Konfig - Composable, observable and performant config handling for Go for the distributed processing era.
• gRPC-Go - Go language implementation of gRPC. HTTP/2 based RPC.
• gocontracts - Tool for design-by-contract in Go.
• apex-go - Golang runtime for Apex/Lambda.
• go-colorful - Library for playing with colors in go.
• go-jira - Simple command line client for Atlassian's Jira service written in Go.
• envsubst - Environment variables substitution for Go.
• gocraft/work - Lets you enqueue and processes background jobs in Go. Jobs are durable and backed by Redis.
• easyjson - Provides a fast and easy way to marshal/unmarshal Go structs to/from JSON without the use of reflection.
• go-elasticsearch - Official Go client for Elasticsearch.
• DiffParser - Golang package which parse's a git diff.
• Minify - Go minifiers for web formats.
• parse - Contains several lexers and parsers written in Go.
• filetype - Small and dependency free Go package to infer file and MIME type checking the magic numbers signature.
• pudge - Fast and simple key/value store written using Go's standard library.
• Wire - Code generation tool that automates connecting components using dependency injection.
• go-consistent - Source code analyzer that helps you to make your Go programs more consistent.
• Webview - Tiny cross-platform webview library for C/C++/Golang. Uses WebKit (Gtk/Cocoa) and MSHTML (Windows).
• sse - Server-Sent Events implementation in Go. Used by the Gin Framework.
• Go Daemon - Daemon package for use with Go (golang) services with no dependencies.
• Go JSON Schema Reflection - Can be used to generate JSON Schemas from Go types through reflection.
• simpletable - Simple tables in terminal with Go.
• Immutable - Immutable collections for Go.
• conjungo - Merge utility designed for flexibility and customizability.
• go-misc - Miscellaneous Go hacks.
• Slim - Surprisingly space efficient data types in Golang.
• go-multierror - Represent a list of errors as a single error.
• jobs - Persistent and flexible background jobs library for go.
• tracerr - Golang errors with stack trace and source fragments.
• go-guerrilla - Mini SMTP server written in golang.
• Fyne - Cross-platform GUI toolkit written in Go. (Web) (HN)
• gofeed - Parse RSS and Atom feeds in Go.
• Logrus - Structured, pluggable logging for Go.
• AwGo - Go library for Alfred workflows.
• Go Keychain - Library for accessing the Keychain for macOS, iOS, and Linux in Go (golang).
• Oto - Low-level library to play sound. This package offers io.WriteCloser to play PCM sound.
• afero - FileSystem Abstraction System for Go.
• Jingo - Provides the ability to encode golang structs to a buffer as JSON very quickly.
• goldmark - Markdown parser written in Go. Easy to extend, standard compliant, well structured.
• wails - Create desktop apps using Go and Web Technologies.
• hashmap - Golang lock-free thread-safe HashMap optimized for fastest read access.
• go-fuzzyfinder - Go library that provides fuzzy-finding with an fzf-like terminal user interface.
• httpmock - HTTP mocking for Golang.
• websocket - A minimal and idiomatic WebSocket library for Go.
• script - Making it easy to write shell-like scripts in Go.
• Sling - Go HTTP client library for creating and sending API requests.
• Geziyor - Fast web crawling & scraping framework for Go.
• demangle - C++ symbol name demangler written in Go.
• gamut - Generate and manage color palettes & schemes.
• sqlx - General purpose extensions to golang's database/sql.
• ggm - Go generic orm, base on sqlx.
• bindata - Turn data file into go code.
• ObjectBox Go API - Persisting your Go structs/objects superfast and simple.
• panicparse - Crash your app in style in Go.
• periph - Peripherals I/O in Go.
• draw2d - 2D rendering for different output (raster, pdf, svg).
• go-systemd - Go bindings to systemd socket activation, journal, D-Bus, and unit files.
• sqlc - Composable, type safe and fluent API to generate nested and complex SQL queries.
• cloudflare-go - Go library for the Cloudflare v4 API.
• valkeyrie - Distributed Key/Value Store Abstraction Library written in Go.
• pstree - Simple minded package to retrieve the process tree from a given PID.
• mysql - MySQL driver for Go's (golang) database/sql package.
• fastcache - Fast thread-safe inmemory cache for big number of entries in Go. Minimzes GC overhead.
• fastcache - HTTP response caching package that plugs into fastglue that simplifies "dumb" caching of API endpoints.
• expr - Evaluate expression in Go. (Lobsters)
• compress - Optimized compression packages.
• Casbin - Authorization library that supports access control models like ACL, RBAC, ABAC in Go. (Web) (HN)
• JobRunner - Framework for performing work asynchronously, outside of the request flow.
• v8go - Execute JavaScript from Go.
• tview - Rich interactive widgets for terminal-based UIs written in Go.
• Jennifer - Code generator for Go.
• nosurf - HTTP package for Go that helps you prevent Cross-Site Request Forgery attacks.
• jit - Go module for executing machine code directly.
• Ristretto - High performance memory-bound Go cache.
• Watermill - Building event-driven applications easy way in Go. (CQRS implementation in Watermill)
• Aero - High-performance web server for Go.
• Jet - Type safe SQL Builder for Go with automatic scan to desired arbitrary object structure.
• Ent - Simple, yet powerful entity framework for Go, that makes it easy to build and maintain applications with large data-models. (Web) (Docs) (GraphQL setup) (entcache) (ent-contrib) (ogent - Ent Extension to integrate ogen) (Should I use Ent?) (HN)
• Muon - Lightweight alternative to Electron written in Go in about ~300 LoC, using Ultralight instead of Chromium. (HN)
• gnet - High-performance, lightweight, non-blocking, event-driven networking framework written in pure Go.
• env - Simple lib to parse envs to structs in Go.
• go-execute - Wrapper for executing commands in Go.
• pie - Code generator for dealing with slices that focuses on type safety, performance and immutability.
• govalidator - Package of validators and sanitizers for strings, numerics, slices and structs.
• gocraft/dbr - Additions to Go's database/sql for super fast performance and convenience.
• httpauth - Go (lang) HTTP session authentication.
• syncmap - Typed implementation of the Go sync.Map using code generation.
• BadgerHold - Embeddable NoSQL store for querying Go types built on Badger.
• jeff - Provides the simplest way manage web sessions in Go.
• GoGi - Native Go (golang) Graphical Interface system (2D and 3D), built on GoKi tree framework.
• sklearn - Partial port of scikit-learn to Go.
• quicktemplate - Fast, powerful, yet easy to use template engine for Go. Optimized for speed, zero memory allocations in hot paths.
• go-sx - Provides some extensions to the standard library database/sql package.
• json-iterator/go - High-performance 100% compatible drop-in replacement of "encoding/json".
• go-pretty - Utilities to prettify console output of tables, lists, text, etc.
• Go Terminput - Provides terminal keyboard input for interactive command-line tools.
• Termd - Provides terminal markdown rendering, with code block syntax highlighting support.
• Tea - Provides an Elm inspired functional framework for interactive command-line programs.
• Lattigo - Lattice-based cryptographic library in Go.
• orderedmap - Ordered map in Go with amortized O(1) for Set, Get, Delete and Len.
• orderedmap - Go data type equivalent to python's collections.OrderedDict.
• validator - Go Struct and Field validation, including Cross Field, Cross Struct, Map, Slice and Array diving.
• cast - Safe and easy casting from one type to another in Go.
• go-reuseport - Reuse tcp/udp ports in golang.
• Genesis - Typesafe concurrent generic functions for Go.
• redis - Efficient Redis client.
• vfsgen - Takes an input http.FileSystem (likely at go generate time) and generates Go code that statically implements it.
• when - Natural language date/time parser with pluggable rules.
• hashstructure - Get hash values for arbitrary values in Go.
• Suture - Provides Erlang-ish supervisor trees for Go.
• Reign - Rewrite Erlang In Go Nicely - a library for mimicking Erlang's mailboxes and clustering.
• null - Reasonable handling of nullable values.
• dynamo - Expressive DynamoDB library for Go.
• Onelog - Dead simple, super fast, zero allocation and modular logger for Golang.
• encoding - Go package containing implementations of efficient encoding, decoding, and validation APIs.
• go-execute - Automate commands with Go.
• go-netstat - Netstat implementation written in Go.
• sqlc - Generate type safe Go from SQL. (Article) (Playground) (How We Went All In on sqlc/pgx for Postgres + Go) (HN)
• Go-Readability - Go package that cleans a HTML page for better readability.
• netlink - Simple netlink library for go.
• desync - Alternative casync implementation.
• errors - Simple error handling primitives.
• logr - Simple logging interface for Go.
• cron - Cron library for go.
• INI - Package ini provides INI file read and write functionality in Go.
• reload - Lightweight automatic reloading of Go processes.
• go-jsonstruct - Generate Go structs from multiple JSON objects.
• service - Run go programs as a service on major platforms.
• Boom Filters - Probabilistic data structures for processing continuous, unbounded streams.
• xorfilter - Go library implementing xor filters.
• fastjson - Fast JSON parser and validator for Go. No custom structs, no code generation, no reflection.
• eris - Provides a better way to handle, trace, and log errors in Go. (HN)
• easypki - Creating a certificate authority the easy way.
• BigCache - Efficient cache for gigabytes of data written in Go. (HN)
• go-geom - Go library for handling geometries.
• endless - Zero downtime restarts for go servers (Drop in replacement for http.ListenAndServe).
• Sprig - Useful template functions for Go templates.
• pdfcpu - PDF processor written in Go.
• Sqlvet - Performs static analysis on raw SQL queries in your Go code base. (HN)
• matchr - Approximate string matching library for the Go programming language.
• oauth2 - OAuth2 client in Go.
• deep - Golang deep variable equality test that returns human-readable differences.
• goleak - Goroutine leak detector.
• dotsql - Golang library for using SQL.
• Authboss - Modular authentication system for the web.
• kafka-go - Kafka library in Go. (Reddit)
• ClickHouse - Golang driver for ClickHouse.
• concurrent-map - Thread-safe concurrent map for go.
• GoJSONQ - Simple Go package to Query over JSON/YAML/XML/CSV Data.
• go-zero-width - Zero-width character detection and removal for Go.
• Automi - Stream processing API for Go.
• go-resiliency - Resiliency patterns for golang.
• Event Horizon - CQRS/ES toolkit for Go.
• FSM - Finite state machine for Go.
• Gonetics - Go Bioinformatics Library.
• go-spew - Implements a deep pretty printer for Go data structures to aid in debugging.
• utter - Fork of the outstanding go-spew tool. Tool for taking snapshots of data structures to include in tests or other code.
• zerolog - Zero Allocation JSON Logger.
• SortedMap - Simple value-sorted map type for Go that features constant-time reads and efficient iteration over records.
• copy - Copy directory recursively.
• regexp2 - Full featured regular expressions for Go.
• fsnotify - Cross-platform file system notifications for Go.
• go-naturaldate - Natural date/time parsing for Go.
• gpio - Native Go library for Raspberry Pi GPIO.
• DJSON - Fast Go decoder for dynamic JSON.
• Gabs - Small utility for dealing with dynamic or unknown JSON structures in Go.
• go-homedir - Go library for detecting and expanding the user's home directory without cgo.
• Pigo - Pure Go face detection library.
• Keyring - Go library providing a uniform interface across a range of secure credential stores.
• email - Robust and flexible email library for Go.
• retry - Simple golang library for retry mechanism.
• go-ps - Find, list, and inspect processes from Go.
• termbox-go - Pure Go termbox implementation.
• skv - Simple, persistent key-value storage for Go. (Article)
• go.rice - Go package that makes working with resources such as html,js,css,images,templates, etc very easy.
• slug - URL-friendly slugify with multiple languages support.
• CurlyQ - Provides a simple, easy-to-use interface for performing background processing in Go.
• Olric - Distributed, eventually consistent, in-memory key/value data store and cache. (HN) (HN)
• licensecheck - Classifies license files and heuristically determines how well they correspond to known open source licenses.
• Cloud Run helpers - Provides a set of Cloud Run helper functions.
• go-ws-transport - WebSocket implementation of a go-libp2p transport.
• go-finance - Contains a collection of financial functions for time value of money (annuities), cash flow, interest rate conversions, bonds and depreciation calculations.
• go-streams - Go stream processing library.
• simdjson-go - Golang port of simdjson: parsing gigabytes of JSON per second.
• Collection of compression libraries for Go
• monkey - Monkey patching in Go. (Fork)
• gopsutil - psutil for golang.
• schedgroup - Provides a goroutine worker pool which schedules tasks to be performed at or after a specified time.
• clog - Channel-based logging package for Go.
• New Relic Go Agent - Allows you to monitor your Go applications with New Relic.
• MemGuard - Secure software enclave for storage of sensitive information in memory.
• Generic and Fast Binary Serializer for Go
• decimal - Arbitrary-precision fixed-point decimal numbers in go.
• Clipboard - Provide copying and pasting to the Clipboard for Go.
• clipboard - Go library for multi-platform clipboard.
• protobuild - Build protobufs in Go, easily.
• wal - Write ahead log for Go.
• protoc-go-inject-tag - Inject custom tags to protobuf golang struct.
• Go support for Protocol Buffers (HN)
• Yamux - Golang connection multiplexing library.
• protostructure - Go library for encoding and decoding a struct type over the wire.
• mapstructure - Go library for decoding generic map values into native Go structures.
• go-expect - Provides an expect-like interface to automate control of applications.
• dque - Fast embedded durable queue for Go.
• netboot - Packages and utilities for network booting.
• image - Set of Go libraries aimed at working in various way with containers' images and container image registries.
• GoAdmin - Golang framework helps gopher to build a data visualization and admin panel in ten minutes. (Web)
• go-app-paths - Lets you retrieve platform-specific paths (like directories for app-data, cache, config, and logs).
• ntp - Simple ntp client package for go.
• Gorgonia - Library that helps facilitate machine learning in Go. (Web) (GitHub)
• pgzip - Go parallel gzip (de)compression.
• txeh - Go library and CLI utilty for /etc/hosts management.
• go-jdk - Run JVM-based code in Go efficiently.
• WUID - Extremely fast UUID alternative written in golang.
• jsonq - Simplify your golang json usage by extracting fields or items from arrays and objects with a simple, hierarchical query.
• SVGo - Go library for SVG generation.
• go-rate - Rate limiter designed for a range of use cases, including server side spam protection and preventing saturation of APIs you consume.
• Throttled - Implements rate limiting access to resources such as HTTP endpoints.
• groupcache - Caching and cache-filling library, intended as a replacement for memcached in many cases.
• littleboss - Self-supervising Go binaries.
• go-basher - Library for writing hybrid Go and Bash programs.
• beeep - Go cross-platform library for sending desktop notifications, alerts and beeps.
• Whatlanggo - Natural language detection for Go.
• hystrix-go - Netflix's Hystrix latency and fault tolerance library, for Go.
• systray - Cross platform Go library to place an icon and menu in the notification area. (Fork)
• SemVer - Work with Semantic Versions in Go.
• APNS/2 - Simple, flexible and fast Apple Push Notifications on iOS, OSX and Safari using the new HTTP/2 Push provider API.
• sanitize - Provides functions for sanitizing text in golang strings.
• Flect - Inflection engine for golang.
• TamaGo - Bare metal Go for ARM SoCs. (Web) (HN)
• Bloom filters - Bloom filter is a representation of a set of n items, where the main requirement is to make membership queries; i.e., whether an item is a member of a set.
• goph - Native golang ssh client to execute your commands over ssh connection.
• mem - Cheap Go type to hold & operate on either a read-only []byte or string.
• cgroups - Go package for creating, managing, inspecting, and destroying cgroups.
• go-codec - Idiomatic codec and rpc lib for msgpack, cbor, json, etc. msgpack.org.
• unik - Go module for running Go programs as unikernels, without an underlying operating system. (HN)
• Mimic - Define your Configuration, Infrastructure and Deployments as Go Code.
• workerpool - Concurrency limiting goroutine pool.
• mimetype - Simple golang library for detecting the MIME type and file extension, based on magic numbers.
• keybd_event - Simulates the key press on a keyboard.
• Confita - Library that loads configuration from multiple backends and stores it in a struct.
• tally - Fast, buffered, hierarchical stats collection in Go.
• JSON-Patch - Go library to apply RFC6902 patches and create and apply RFC7386 patches.
• go-internal - Selected Go-internal packages factored out from the standard library.
• xattr - Extended attribute support for Go (linux + darwin + freebsd).
• watcher - Go package for watching for files or directory changes without using filesystem events.
• nmap - Idiomatic nmap library for go developers.
• Fx - Dependency injection based application framework for Go. (Article) (HN)
• channels - Collection of helper functions and special types for working with and extending Go's existing channels.
• combinator - Generates a slice of all possible value combinations for any given struct.
• NTP - Collection of Facebook's NTP libraries.
• Ergo - Framework for creating microservices using technologies and design patterns of Erlang/OTP in Go. (Lobsters) (Tweet) (Web) (HN)
• go-diff - Diff, match and patch text in Go.
• circuitbreaker - Provides an easy way to use the Circuit Breaker pattern in a Go program.
• UniPDF - Golang PDF library for creating and processing PDF files.
• OpenTelemetry-Go - OpenTelemetry Go API and SDK.
• barcode - Barcode creation lib for golang.
• gomarkdown/markdown - Markdown Parser and HTML Renderer for Go.
• totp - Golang two factor authentication library.
• Orchestra - Library to manage long running go processes.
• Emitter - Implements a channel-based pubsub pattern.
• micron - Minimal implementation of the fault-tolerant job scheduler.
• addchain - Cryptographic Addition Chain Generation in Go.
• go-farm - Google's FarmHash hash functions implemented in Go.
• bleve - Modern text indexing library for go. (Web)
• glob - Go Globbing Library.
• exhaustive - Ensure exhaustiveness of enum switch statements in Go code.
• stream - Provides filters that can be chained together in a manner similar to Unix pipelines.
• MinIO Go Client SDK - Provides simple APIs to access any Amazon S3 compatible object storage.
• go-echarts - Adorable charts library for Golang.
• go-bluetooth - Go bluetooth API for Linux-based Bluez DBus interface.
• subcommands - Implements a simple way for a single command to have many subcommands, each of which takes arguments and so forth.
• RxGo - Reactive Extensions for the Go language. (Announcing RxGo v2)
• screenshot - Go library to capture desktop to image.
• cel-go - Fast, portable, non-Turing complete expression evaluation with gradual typing.
• uuid - Go package for UUIDs based on RFC 4122 and DCE 1.1: Authentication and Security Services.
• sys - Go packages for low-level interaction with the operating system.
• zek - Generate a Go struct from XML.
• go-diodes - Diodes are ring buffers manipulated via atomics.
• Asynq - Go library for queueing tasks and processing them in the background with workers. (Asynqmon)
• appy - Opinionated productive web framework that helps scaling business easier.
• wasmtime-go - Go WebAssembly runtime powered by Wasmtime.
• html2text - Converts HTML into text of the markdown-flavored variety.
• Aurora - Golang ultimate ANSI-colors that supports Printf/Sprintf methods.
• FTMPL - Fast typesafe templating for golang.
• jio - JSON schema validator similar to joi.
• gearbox - Web framework for building micro services written in Go with a focus on high performance and memory optimization.
• Go App Engine packages - Provides APIs for interacting with App Engine services.
• saml - Simple, secure, pluggable Golang implementation of SAML.
• golang-whois - Get whois info using root servers.
• circbuf - Provides a Buffer object which is a circular (or ring) buffer. It has a fixed size, but can be written to infinitely.
• fuse - Go package for implementing a FUSE file system.
• go-serial - Allows you to read from and write to serial ports in Go.
• doubleratchet - Double Ratchet Algorithm implementation in Go.
• ipvs - Allows you to manage Linux IPVS services and destinations.
• gojsonschema - Implementation of JSON Schema.
• Phony - Ponylang-inspired actor model library for Go.
• faker - Fake Data Generator for Struct.
• go-radix - Golang implementation of Radix trees.
• smtprelay - Simple Golang SMTP relay/proxy server.
• wav - Battle tested Wav decoder/encoder.
• Go-Readability - Cleans a HTML page for better readability.
• DOM - Access and manipulate DOM element in HTML file.
• Obelisk - Go package and CLI tool for saving web page as single HTML file.
• baseplate.go - Baseplate implemented in go.
• msgpack - MessagePack encoding for Golang.
• go-sumtype - Simple utility for running exhaustiveness checks on Go "sum types.".
• pkg/json - Efficient JSON decoder.
• OjG - Optimized JSON for Go is a high performance parser with a variety of additional JSON tools.
• fuzzy - Implements fuzzy matching/sorting of string slices and custom types.
• Gofakeit - Random fake data generator written in go.
• Got - Simple and fast concurrent downloader.
• CCache - LRU Cache, written in Go, focused on supporting high concurrency.
• otp - One Time Password utilities Go.
• Pogreb - Embedded key-value store for read-heavy workloads written in Go.
• terrors - Package for wrapping Golang errors. Terrors provides additional context to an error, such as an error code and a stack trace.
• GoFPDF - PDF document generator with high level support for text, drawing and images.
• Bolt - Embedded key/value database for Go.
• Golang Network File Server - NFSv3 protocol implementation in pure Go. (HN)
• Dump - One function library to simplify local print debug.
• Go-Diagrams - Create beautiful system diagrams with Go. (HN)
• Bluge - Modern text indexing in go.
• Typed - Wrapper around map[string]interface{} to provide some strong typing.
• Purell - Go library to normalize URLs.
• Vasto - Distributed key-value store. On Disk. Able to grow or shrink without service interruption.
• cascadia - CSS selector library in Go.
• brotli - Pure Go Brotli encoder and decoder.
• Leaven - Compile LLVM IR to Go.
• Hub - Fast enough Event Hub for go applications using publish/subscribe with support patterns on topics like rabbitMQ exchanges.
• Buffer - Composable Buffers for Go.
• Stream - Stream bytes to multiple independent Readers.
• fscache - Streaming File Cache for Go.
• times - Go file times (atime, mtime, ctime, btime).
• nio - Concurrent Buffered IO in Go.
• go-ristretto - Go implementation of the group operations on the Ristretto prime-order group built from Edwards25519.
• ncw/swift - Easy to use library for interfacing with Swift / Openstack Object Storage / Rackspace cloud files from the Go Language.
• GoFlow - Flow-based and dataflow programming library for Go.
• io_uring-go - Provides friendly async IO interface with io_uring.
• hrtime - High resolution timing and benchmarking for Go.
• CRDT - Go implementation of CRDTs.
• XID - Globally unique id generator library, ready to safely be used directly in your server code.
• Libcache - Lightweight in-memory key:value cache library for Go.
• tldr - Text summarizer for go using LexRank.
• ln - Natural log function. (Article)
• Gohalt - Simple and convenient yet powerful and efficient throttling go library.
• gox - Extension of Go's syntax that let's you write HTML-style tags directly in your source code.
• Pirsch - Drop-in, server-side, no-cookie, and privacy-focused tracking solution for Go.
• Birdland - Battle-tested recommendation library written in Go.
• dataframe-go - DataFrames for Go: For statistics, machine-learning, and data manipulation/exploration.
• google-search - Scrape google search results.
• workerpool - Auto scaling generic worker pool.
• Wabbit - Go AMQP mocking library.
• goioc/di - Simple and yet powerful Dependency Injection for Go.
• hcl - Parsing, encoding and decoding of HCL to and from Go types and an AST.
• cache2go - Concurrency-safe Go caching library with expiration capabilities and access counters.
• go-encoding - Go package which abstracts various encoding mechanisms under a unified API.
• go-cache - Go package which abstracts cache systems.
• GWeb - Interact with browser from Go. Manually-crafted WebAPI interoperation library.
• govips - Fast image processing library for Go.
• go-randomdata - Tiny help suite for generating random data.
• go-getter - Package for downloading things from a string URL using a variety of protocols.
• Gozip - Create self extracting executable zip files in Go.
• csvutil - Provides fast and idiomatic mapping between CSV and Go values.
• go-scp - Makes it easy to copy files over scp in Go.
• Go Sync - Provides Go concurrency primitives in addition to the ones provided by the language and "sync" and "sync/atomic" packages.
• aconfig - Simple, useful and opinionated config loader.
• stateful - Finite state machine for Go.
• logfmt - Marshals and unmarshals logfmt messages.
• dagger - Fast, concurrency safe, mutable, in-memory directed graph library with zero dependencies.
• go-text - Go libraries to operate text.
• go-edn - Go implementation of EDN.
• Machine - Zero dependency library for highly concurrent Go applications. It is inspired by errgroup.Group with extra bells & whistles.
• go-tc - Traffic control in pure go - it allows to read and alter queues, filters and classes.
• go-version - Library for parsing versions and version constraints, and verifying versions against a set of constraints.
• qs - Go module for encoding structs into URL query parameters.
• Enumer - Tool to auto generate methods for your enums.
• OpenTelemetry-Go Contrib - Collection of 3rd-party instrumentation and exporters for OpenTelemetry-Go.
• structtag - Parse and modify Go struct field tags.
• Functions Framework for Go - (Function as a service) framework for writing portable Go functions.
• ecs - Go implementation of the Entity/Component/System paradigm.
• otel-launcher-go - Lightstep Distro for OpenTelemetry Go.
• fileglob - File globbing library.
• Perf - Go library for interacting with the perf subsystem in Linux.
• uniseg - Unicode Text Segmentation for Go.
• Gota - DataFrames, Series and Data Wrangling for Go.
• vfs - Pluggable, extensible virtual file system for Go.
• Deepcopier - Meant to make copying of structs to/from others structs a bit easier.
• webauthn - Web Authentication API in Go.
• Beep - Package that brings sound to any Go application. Suitable for playback and audio-processing.
• strcase - Go package for converting string case to various cases.
• keyboard - Simple library to listen for keystrokes from the keyboard.
• go-lock - Lock library implementing read-write mutex and read-write trylock without starvation.
• go.uuid - UUID package for Go.
• graph - Graph algorithms and data structures.
• phonenumbers - Parsing, formatting, and validating international phone numbers.
• gonfig - Go package for program configuration.
• ghw - Go hardware discovery/inspection library.
• jwt - JSON Web Token for Go.
• go-set - Type-safe, zero-allocation sets for Go.
• slice - Functional utilities from Lodash for working with slices in Go.
• go-yaml - YAML support for the Go language.
• Feature flags API in Go
• wego - Word Embeddings (e.g. Word2Vec) in Go.
• Gotcha - Seamlessly patches go runtime to provide a convenient way to track amount of heap allocated bytes, objects, calls per goroutine.
• go-shellwords - Parse line as shell words.
• deephash - Library for calculating a deterministic hash for simple or nested data structures in Go.
• mangos - Go implementation of nanomsg's "Scalablilty Protocols".
• exp - Experimental and deprecated packages.
• mmap-go - Portable mmap package for Go.
• flock - Thread-safe file locking library in Go.
• Nero - Library for generating the repository layer code.
• jsondiff - Go package for computing the diff between two JSON documents.
• GoDotEnv - Load environment variables from .env.
• json-lossless - Lossless JSON encoding/decoding package in Go.
• gocelery - Go Client/Server for Celery Distributed Task Queue.
• go-concise-encoding - Go implementation of Concise Binary and Text Encoding.
• fswatch - Go library for monitoring filesystem changes that does not depend on inotify.
• GoJay - Performant JSON encoder/decoder for Go.
• gg-git - High-level interface for interacting with a Git subprocess in Go.
• goimagehash - Go Perceptual image hashing package.
• ember - Embed arbitrary resources into a go executable at runtime, after the executable has been built.
• deque - Implements a very fast and efficient general purpose queue/stack/deque data structure.
• taskflow - Create build pipelines in Go.
• Diff - Library for diffing go structures.
• valast - Convert Go values to their AST.
• nanoQ - High-performance brokerless Pub/Sub for streaming real-time data.
• prettyjson - JSON pretty print for Go.
• regroup - Simple library to match regex expression named groups into go struct using struct tags and automatic parsing.
• quacktors - Go framework that brings Erlang/Elixir style concurrency to Go.
• Smux - Stream Multiplexing Library for go with least memory usage.
• Fuzzy Search - Tiny and fast fuzzy search in Go.
• msgp - Go code generator for MessagePack.
• SipHash - Go implementation of SipHash-2-4, a fast short-input PRF.
• Gobls - Buffered line scanner for Go.
• goswarm - Go Stale While Asynchronously Revalidate Memoization.
• tachymeter - Go library for timing things and yielding rates, percentiles, and histograms.
• reflow - Collection of (ANSI-sequence aware) text reflow operations & algorithms.
• kube-exec - Lightweight Go package for executing commands in remote Kubernetes pods.
• fuse - Go library for writing FUSE userspace filesystems.
• Gocache - Complete Go cache library that brings you multiple ways of managing your caches.
• Configor - Go Configuration tool that support YAML, JSON, TOML, Shell Environment.
• TTLCache - In-memory cache with expiration.
• metric - Minimal metrics for Go (counter/gauge/histogram). No dependencies. Compatible with expvar. Web UI included..
• pie - Toolkit for creating plugins for Go applications.
• lz4 - LZ4 compression and decompression in pure Go.
• run - Universal mechanism to manage goroutine lifecycles.
• go-concurrency-limits - Go implementation of Netflix/concurrency-limits.
• go-query - Blazingly fast query engine.
• AQL - Lucene-inspired query language for Go.
• raft - Go implementation of the Raft consensus protocol.
• sha256-simd - Accelerate SHA256 computations in pure Go.
• go-ordered-map - Same as regular maps, but also remembers the order in which keys were inserted.
• GoAudio - Go tools for audio processing & creation.
• stripeutil - Utility functions and data structures for working with the Stripe API for builing a SaaS application.
• vmtest - Go framework for integration testing with Virtual machines (e.g. QEMU).
• genny - Elegant generics for Go.
• faktory_worker_go - Faktory workers for Go.
• go-financial - Go port of numpy-financial functions and more.
• Arista Go library - Helper functions to work with the reflect package.
• Fusion - Tiny stream processing library written in Go.
• Go Fluent FFmpeg - Bindings to FFmpeg.
• go-json - Fast JSON encoder/decoder compatible with encoding/json for Go. (HN)
• webhooks - Allows for easy receiving and parsing of GitHub, Bitbucket and GitLab Webhook Events.
• mainthread - Run stuff on the main thread in Go.
• ebml-go - Pure Go implementation of bi-directional EBML encoder/decoder.
• dither - Fast, correct image dithering library in Go.
• BTree - Provides a simple, ordered, in-memory data structure for Go programs.
• gocron - Go job scheduling package which lets you run Go functions periodically at pre-determined interval using a simple, human-friendly syntax.
• got-reload - Reload Go code in a running process at function/method level granularity, using Yaegi.
• Workerpool - Run tasks concurrently with limits.
• GoFP - Lodash like utility library for Go.
• structomap - Helps you to transform your struct into map easily.
• date - Go package for working with dates.
• GCache - Cache library for golang. It supports expirable Cache, LFU, LRU and ARC.
• gcnotifier - Know when GC runs from inside your Go code.
• go-github-selfupdate - Go library to provide a self-update mechanism to command line tools.
• btree - Efficient B-tree implementation in Go.
• log - Structured logging package for Go.
• Go Data Structures
• fs2 - B+ Tree - List - File Structures 2 - Memory Mapped File Structures for Go.
• go-selfupdate - Enable your Go applications to self update.
• Gochan - Turns io.ReadWriter interface into channels.
• mathfmt - Document mathematical Go code beautifully.
• generics - Quick experiments with Go generics.
• slicegraph - Uses graphviz in order to pretty print slices for you.
• scriptish - Library to help you port bash scripts to Go.
• Project Flogo - Ultra-light, Go-based open source ecosystem for building event-driven apps. (Web)
• go-hypercore - Hypercore implementation in Go.
• gostackparse - Parse go stack traces at ~300 MiB/s.
• perf - Go performance measurement, storage, and analysis tools.
• go-edlib - Edit distance and string comparison library.
• go-billy - Missing interface filesystem abstraction for Go.
• gronx - Lightweight, fast and dependency-free Cron expression parser.
• synx - Better sync package for Go.
• fastime - Super fast time function library for Go with zero memory allocation. Returns the approximate time.
• Redsync - Distributed mutual exclusion lock using Redis for Go.
• PEG - Peg, Parsing Expression Grammar, is an implementation of a Packrat parser generator.
• Grafana Plugin SDK for Go - Go SDK for building backend plugins for Grafana.
• monkit - Flexible process data collection, metrics, monitoring, instrumentation, and tracing client library for Go.
• ants - High-performance and low-cost goroutine pool in Go.
• Reactr - Fast, performant function scheduling system for Go & WebAssembly.
• Grav - Embedded distributed messaging mesh for Go applications.
• vellum - Go library implementing an FST (finite state transducer).
• GCI - Tool that control Go package import order and make it always deterministic.
• imgutil - Helpful utilities for working with images.
• rjson - Fast JSON parser for go.
• fungo - Generic, lazy, concurrent Go2 collections, result, maybe wrappers and all kinds of sweet functional goodness to operate upon them.
• tmplfunc - Go templates invoked as functions.
• go-toml - Go library for the TOML format.
• OSIN - Go OAuth2 server library.
• sroar - Serialized Roaring Bitmaps.
• csvtk - Cross-platform, efficient and practical CSV/TSV toolkit in Go.
• Go Debug - Utilities and libraries for debugging Go programs.
• codec - Fast Encoding of Go Values.
• defaults - Initialize structs with default values.
• go-daemon - Library for writing system daemons in Go.
• retag - Change tags of structures' fields in runtime without copying of data in Go. Conditional marshalling and unmarshalling.
• go-sundheit - Library built to provide support for defining service health for Go services.
• Render - Provides functionality for easily rendering JSON, XML, text, binary data, and HTML templates.
• LimitIO - Go io.Reader and io.Writer with limit.
• notify - File system event notification library on steroids.
• Sonic - Blazingly fast JSON serializing & deserializing library. (HN)
• Mango Cache - Partial implementations of Guava Cache in Go.
• Go Nanoid - Go random IDs generator.
• glog - Leveled execution logs for Go.
• QOR OSS - Provides common interface to operate files in cloud storage/filesystem.
• Tabby - Tiny library for super simple Go tables.
• kademlia - Go implementation of a Kademlia distributed hash table.
• autopprof - Pprof made easy at development time.
• reflect2 - Reflect API without runtime reflect.Value cost.
• S2 - S2 geometry library in Go.
• Gollum - n:m multiplexer that gathers messages from different sources and broadcasts them to a set of destinations.
• config - Configuration for Go applications.
• zap - Blazing fast, structured, leveled logging in Go.
• NBIO - High-performance, non-blocking, event-driven, easy-to-use, least-dependency networking framework written in Go.
• ARPC - More effective network communication, two-way calling, notify and broadcast supported.
• Copier - Copy value from struct to struct and more.
• PubSub - Publish & Subscribe library, with pluggable providers and middleware for Go.
• Jettison - Fast and flexible JSON encoder for Go.
• Column - High-performance, columnar, in-memory store with bitmap indexing in Go. (HN)
• smutex - Sharded Mutex in Go.
• Lexical - Set of tools for building parsers using Go.
• EventBus - Lightweight eventbus with async compatibility for Go.
• bytebufferpool - Implementation of a pool of byte buffers with anti-memory-waste protection.
• PHC Crypto - Hashing algorithms simplified.
• bitmap - SIMD-Vectorized Bitmap (Bitset) in Go.
• tinylru - Fast little LRU cache.
• Go Rules Engine - Helpful in situations where you have a generic rule and want to verify if your values (specified using map[string]interface{}) satisfy the rule.
• jsonparser - Alternative JSON parser for Go (10x times faster standard library).
• log - Minimal and extensible structured logger.
• Stealthpool - Provides a memory pool that allocates blocks off-heap that will NOT be tracked by the garbage collector.
• koanf - Light weight, extensible, configuration management library for Go.
• Puddle - Tiny generic resource pool library for Go that uses the standard context library to signal cancellation of acquires.
• go-arm64 - Pure Go AARCH64 architecture disassembler.
• AirplayMirroringGo - Cross platform AirPlay mirroring client by Go.
• Harmonica - Simple, efficient spring animation library.
• JSON Serialization (v2) - Experimental implementation of a proposed v2 encoding/json package.
• memfs - In-memory implementation of Go's io/fs.FS interface.
• ulid - Universally Unique Lexicographically Sortable Identifier (ULID) in Go.
• scrapligo - Connecting to devices, specifically network devices (routers/switches/firewalls/etc.) via SSH and NETCONF.
• Cuckoo Filter - Bloom filter replacement for approximated set-membership queries.
• PubNub Go SDK
• strftime - Fast strftime for Go.
• sorty - Fast Concurrent / Parallel Sorting in Go.
• go-car - Library to interact with merkledags stored as a single file.
• functional-go - Functional programming in Go. Inspired by Clojure.
• unixtransport - Support for Unix domain sockets in Go HTTP clients.
• fwd - Buffered Reader/Writer.
• Ladon - SDK for access control policies: authorization for the microservice and IoT age. Inspired by AWS IAM policies. Written for Go.
• go-semver - Semantic Versioning Library.
• gosom - Self-organizing maps in Go.
• netaddr - Network address types.
• Grabana - User-friendly Go library for building Grafana dashboards.
• saferith - Constant time big numbers for Go.
• percpu - Go package to support best-effort CPU-local sharded values.
• Conform - Trim, sanitize, and modify struct string fields in place, based on tags.
• cpuid - CPU feature identification for Go.
• Jade - Pug template engine for Go.
• asm - Go library providing algorithms optimized to leverage the characteristics of modern CPUs.
• Dragonboat - High performance multi-group Raft consensus library in pure Go.
• RSDic - Go library for space-efficient rank/select operations for both sparse and dense bit arrays.
• Scriggo - World’s most powerful template engine and Go embeddable interpreter. (Web)
• browser - Provides helpers to open files, readers, and urls in a browser window. (Fork)
• go-quartz - Simple, zero-dependency scheduling library for Go.
• Pion MediaDevices - Provides access to media input devices like cameras, microphones, and screen capture.
• dot - Go package for writing descriptions using the Graphviz DOT language.
• multiline-jsonl - Read and write multiline JSONL in Go.
• xdp - Allows one to use XDP sockets from Go.
• go-deadlock - Online deadlock detection in go.
• algo2 - Algorithms written using go2go.
• go-streams - Stream Collections for Go. Inspired in Java 8 Streams and .NET Linq.
• more - Plausible additions to Go standard library packages.
• Queue - Go library for spawning and managing a Goroutine pool, Allowing you to create multiple worker according to limit CPU number of machine.
• glg - Simple and blazing fast lockfree logging library for Go.
• gobreaker - Circuit Breaker implemented in Go.
• go-memexec - Small library that executes code from the memory.
• Stateless - Create state machines and lightweight state machine-based workflows directly in Go code.
• go-maquina - Create finite-state machines in Go. Inspired by stateless.
• gltf - Go module for efficient and robust serialization/deserialization of glTF 2.0.
• NFF-Go - Set of libraries for creating and deploying cloud-native Network Functions (NFs).
• Functional Programming Core Libraries
• Dogs - Make Go functional with dogs.
• grab - Download manager package for Go.
• go-queue - Kafka, Beanstalkd Pub/Sub framework.
• go-yaml - YAML support for Go.
• Unusual Generics - Collection of unusual generics usecases in Go.
• Mustache - Mustache template language in Go.
• go-obj - Object file abstractions in Go.
• storage - Go library which aims to provide methods for storing filesystem layers, container images, and containers.
• Helium - Small, simple, modular constructor with some pre-built components for your convenience.
• Goment - Go time library inspired by Moment.js.
• Go-string - Useful Go String methods.
• oversight - Erlang-like supervisor trees.
• Downsampling Algorithm - Downsampling time series data algorithm in Go.
• Go-ReJSON - Go client for ReJSON Redis Module.
• q - Better way to do print statement debugging.
• lumber - Dead simple, pretty, and feature-rich logger for Go.
• promise - Promise / Future library for Go.
• UUID - UUID generator for Go.
• aho-corasick - Efficient string matching in Go via the aho-corasick algorithm.
• Defaults - Enforce default values on struct fields.
• Limiters - Distributed rate limiters for Go.
• go-nsq - Official Go package for NSQ.
• go-parsing - Multi-Package Go Repo Focused on Text Parsing, with Lexers, Parsers, and Related Utils.
• Atree - Scalable arrays and scalable ordered maps.
• go-peertaskqueue - Prioritized queue of abstract tasks distributed among peers.
• GoCSV - Package aims to provide easy serialization and deserialization functions to use CSV in Go.
• Grafana Dskit - Distributed systems kit.
• pongo2 - Django-syntax like template-engine for Go.
• sigstore - Common go library shared across sigstore services and clients.
• procfs - Functions to retrieve system, kernel and process metrics from the pseudo-filesystem proc.
• Hunch - Provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive.
• Expect - Implementation of Expect in Go.
• Go development helpers (Article)
• replace - Streaming text replacement for Go.
• Zapr - logr implementation using Zap.
• weightedrand - Fast weighted random selection for Go.
• zlog - Secure logger in Go to avoid output sensitive data in log.
• periph - Peripherals I/O in Go.
• T-Digest - Fast map-reduce and parallel streaming friendly data-structure for accurate quantile approximation.
• go-topics - Latent Dirichlet Allocation.
• jx - JSON encoding and decoding.
• fastlfu - LFU cache with O(1) runtime complexity for all operations: insertion, access and deletion (eviction).
• Sudo - Bypasses restrictions on reflect.
• gonp - diff algorithm in Go.
• gographviz - Parses the Graphviz DOT language in Go.
• Kazaam - Arbitrary transformations of JSON in Go.
• Schema Registry Client
• GAAD - Go Advanced Audio Decoder.
• modbus - Fault-tolerant, fail-fast implementation of Modbus protocol in Go.
• packngo - Go client for the Equinix Metal API.
• HybridCache - Multi-level cache library with cache stampede prevention for Go.
• zerodriver - Zerolog based logging library optimized for Cloud Logging.
• go-misc - Miscellaneous Go hacks.
• log - Simple, highly configurable, Structured Logging library.
• form - Decodes url.Values into Go value(s) and Encodes Go value(s) into url.Values. Dual Array and Full map support.
• mold - General library to help modify or set data within data structures and other objects.
• pkg - Extends the core Go packages with missing or additional functionality built in.
• mod - Go module mechanics libraries.
• IAVL - Merkleized IAVL+ Tree implementation in Go.
• Pipeline - Package to build multi-staged concurrent workflows with a centralized logging output.
• randid - Alternative random id generation to UUID.
• SJSON - Set JSON values very quickly in Go.
• sentry-go - Official Sentry SDK for Go.
• Roulette - text/template based package which triggers actions from rules defined in an xml file.
• pond - Minimalistic and High-performance goroutine worker pool written in Go.
• localcache - Local atomic cache manager.
• redislock - Simplified distributed locking implementation using Redis.
• docconv - Converts PDF, DOC, DOCX, XML, HTML, RTF, etc to plain text.
• parquet-go - Go package to read and write parquet files.
• tail - Go package for reading from continuously updated files (tail -f).
• gcslock - Simple, scalable, distributed mutex for serializing computations anywhere on the Internet.
• xxhash - Go implementation of the 64-bit xxHash algorithm (XXH64).
• go-qemu - Go packages to interact with QEMU using the QEMU Machine Protocol (QMP).
• Proto Actor - Ultra fast distributed actors for Go, C# and Java/Kotlin.
• cache - LRU-based cache package for Go. (Reddit)
• ps - List, find and inspect operating system processes in Go.
• lane - Queue, priority queue, stack and deque data structures implementations.
• Reflections - High level abstractions over reflect library.
• dynamic-struct - Go package for editing struct's fields during runtime and mapping structs to other structs.
• decimal - High-performance, arbitrary-precision, floating-point decimal library.
• apd - Arbitrary-precision decimals for Go.
• now - Time toolkit for Go.
• reflectwalk - Go library for "walking" complex structures, similar to walking a filesystem.
• go-diskfs - Go library for performing manipulation of disks, disk images and filesystems.
• uint256 - Fixed size 256-bit math library.
• hcloud - Go library for the Hetzner Cloud API.
• dProxy - Proxy to access interface{} (document) by simple query.
• Gommon - Common packages for Go.
• Jin - Fastest JSON interperter for Go.
• clockwork - Simple fake clock for Go.
• go-heaps - Reference implementations of heap data structures in Go.
• geodist - Compute the distance between two geographic latitude, longitude coordinates. (Reddit)
• go-verkle - Go implementation of Verkle trees.
• go-sarif - Go library for sarif - Static Analysis Results Interchange Format.
• atomix - Better sync/atomic package for Go.
• Go Telemetry SDK
• go-bloomindex - Bloom-filter based search index.
• Go Keyring - OS-agnostic library for setting, getting and deleting secrets from the system keyring.
• MapReduce - Easy-to-use Map Reduce Go framework.
• iostream - Simple Binary Stream Reader/Writer.
• pointer - Helpers to get pointers to values of built-in types.
• thumbnailer - Go media thumbnailer.
• bitset - Go package implementing bitsets.
• Lockgate - Cross-platform distributed locking library for Go.
• raft - Go library that provides a simple, clean, and idiomatic implementation of the Raft consensus protocol.
• go-discover - Go library and command line tool to discover ip addresses of nodes in cloud environments based on meta information like tags provided by the environment.
• thriftrw-go - Thrift encoding code generator and library for Go.
• go-pattern-match - Pattern matchings for Go.
• golang-set - Simple set type for the Go language.
• deep-copy - Tool for generating DeepCopy() functions for a given type.
• envconfig - Small library to read your configuration from environment variables.
• Optional - Library of optional Go types.
• ringbuffer - Circular buffer (ring buffer) in Go, implemented io.ReaderWriter interface.
• generic - Collection of generic data structures written in Go.
• go-generics-example - Example code for Go generics.
• upfluence/pkg
• fx - Useful functional programming helpers.
• Thixo - Template functions for Go templates.
• gohive - Highly Performant and easy to use goroutine pool for Go.
• functools - Functional tools in Go 1.18 using newly introduced generics.
• fpGo - Monad, Functional Programming features for Go.
• Roger - Go RServe client. Use R from Go.
• printsrc - Print Go values as Go source.
• Ent - Universal, scalable, general purpose, Content-Addressable Store (CAS) to explore verifiable data structures, policies and graphs.
• cuid - Collision-resistant hashes for the cloud, in Go.
• Kaitai Struct - Declarative language used for describe various binary data structures.
• openid.go - OpenID consumer implementation in Go.
• go-graph-layout - Graph Layout Algorithms in Go.
• xz - Pure Go package for reading and writing xz-compressed files.
• i18n - Internationalization and localization for your Go applications.
• LMSTFY - Implements task queue in Go which based on Redis storage.
• gexe - Script-like OS interaction wrapped in the security and type safety of the Go programming language.
• gotextdiff - Unified text diffing in Go.
• lingua-go - Most accurate natural language detection library in the Go ecosystem, suitable for long and short text alike. (HN)
• clipboard - Cross platform (macOS/Linux/Windows/Android/iOS) clipboard package in Go.
• Molizen - Typed actor framework for Go.
• FreeCache - Cache library for Go with zero GC overhead and high concurrent performance.
• mapreduce - In-process MapReduce tool to help you to optimize service response time.
• Rad - Concurrent lock free radix tree implementation for go.
• JWZ - Go implementation of the JWZ email threading algorithm.
• batchAggregator - Designed to chew through a bunch of parquet files containing events.
• parquet-go - Pure Go library for reading/writing parquet file.
• ffmpeg-go - Go binding for ffmpeg.
• Goterators - Util library that support aggregate & transforms functions list in Go.
• memlog - Kafka log structure inspired in-memory and append-only data structure.
• parquet-go-source - Source provider for parquet-go.
• Retry - Simple and easy retry mechanism package for Go.
• Lancet - Comprehensive, efficient, and reusable util function library of go.
• rosie - Task building library that allows combining custom logic with the execution of command line programs.
• keyfunc - Create a jwt.Keyfunc for JWT parsing with a JWK Set or given cryptographic keys (like HMAC) in Go.
• protocol - Implements Language Server Protocol specification in Go.
• fieldalignment - Defines an Analyzer that detects structs that would use less memory if their fields were sorted.
• jscan - High performance JSON iterator for Go.
• llparser - Universal LL top-down parser written in Go.
• JsonDiff
• GoLLRB - Left-Leaning Red-Black (LLRB) implementation of balanced binary search trees for Go.
• base62 - Compact and high performance implementation of base62 algorithm for Go.
• go-generics-cache - Key:value store/cache library written in Go 1.18 generics. LRU, LFU, FIFO, MRU, Clock support.
• go-collections - Generic utility functions for dealing with collections in go. (Reddit)
• mp4ff - Implements MP4 media file parsing and writing for AVC and HEVC video, AAC audio and stpp/wvtt subtitles.
• Struc - Better binary packing for Go.
• DI - Dependency injection for Go.
• go-ddd - Practical implementation of Domain Driven Design in Go.
• Kinsumer - Native Go consumer for AWS Kinesis streams.
• dynamodbstreams-kinsume - DynamoDB Streams Adapter for Kinsumer.
• Bifrost - Cross-platform modular communications library & daemon for Go w/ flexible protobuf+yaml config.
• GoSTL - Algorithms and data structures library for Go similar to C++ STL. (HN)
• go-functional - Functional Programming in Go.
• timediff - Go library for printing human readable, relative time differences.
• shortuuid - Go library that generates concise, unambiguous, URL-safe UUIDs.
• jsonschema - json-schema compilation and validation.
• spew - Implements a deep pretty printer for Go data structures to aid in debugging.
• crunch - Library for easily manipulating bits and bytes in Go.
• teivah/onecontext - Set of Go context's utilities.
• btree - Go implementation of a B-Tree.
• prism - Color management for Go.
• GoHook - Go global keyboard and mouse listener hook.
• CancelReader - Cancelable reader for Go.
• iconv - Convert string to requested character encoding.
• dbus - Native Go bindings for D-Bus.
• message-bus - Go simple async message bus.
• go-textdistance - Calculate various text distance with Go.
• strutil - Go metrics for calculating string similarity and other string utility functions.
• Envconfig - Go library for parsing struct tags from environment variables.
• go-msg - Pub/Sub Message Primitives for Go.
• goczmq - Go wrapper for CZMQ.
• Logz - Go library for grouping a access log and application logs.
• GoRE - Library for analyzing Go binaries.
• asciigraph - Go package to make lightweight ASCII line graphs.
• GLSP - Language Server Protocol SDK for Go.
• Config - Library for working with structured configuration in Go.
• smart.go - Pure-Go library to access drive's S.M.A.R.T. information.
• avro - Apache AVRO for go.
• nexus - Full-feature WAMP v2 router and client written in Go.
• social-go - Go parser for various social media handles and URLs.
• xsync - Concurrent data structures for Go. An extension for the standard sync package.
• dd-trace-go - Go tracing package for Datadog APM.
• byline Reader - Reading and processing data from a io.Reader line by line. Can add UNIX text processing principles to its Reader (like with awk, grep, sed ...).
• Go Type Tools - Library containing useful functions for working with Go types like filters, union, intersection and more.
• ut - Yet Another Efficient Unification Algorithm.
• pretty - Pretty printing for Go values.
• parquet-go - High-performance Go library to manipulate parquet files.
• golines - Go formatter that fixes long lines.
• Bell - Simplest event system written in Go which is based on the execution of handlers independent of the main channel.
• Shoutrrr - Notification library for gophers and their furry friends.
• smb2 - SMB2/3 client implementation.
• goseaweedfs - Complete Go client for SeaweedFS.
• gosmpp - SMPP Client Library for Go.
• gumble - Collection of high-performance, thread-safe, lock-free data structures for go.
• Go NVML - Go Bindings for the NVIDIA Management Library.
• Go NVML
• go-i18n - Translate your Go program into multiple languages.
• Adaptive Radix Trees in Go
• Clean Env - Minimalistic configuration reader.
• Skiplist - Fast Skiplist Implementation.
• SAML - SAML is a standard for identity federation.
• go-xstate - XState written in Go.
• slices - Utility package for working with slices.
• async - Alternate patterns for dealing with asynchronous code in go.
• Juniper - Extended Go standard library using generics, including containers, iterators, and streams. (Reddit)
• go-runewidth - Functions to get fixed width of the character or string.
• ControllerBus - Structure large Go programs as communicating concurrent control loops.
• treeprint - Simple ASCII tree composing tool.
• Merkle Tree - Merkle Tree implementation written in Go.
• New Relic Go Client
• Fast JSON encoding
• lo - Lodash-style Go library based on Go 1.18+ Generics (map, filter, contains, find...). (Lobsters)
• mast - Go immutable, versioned, diffable map implementation of Merkle Search Trees.
• MP4 - Basic MP4 reader in Go.
• Blobloom - Extremely fast Bloom filters for Go.
• fastimage - Fast image info for go.
• fasttime - Fast time formatting for go.
• zap - Alternative logging through zap.
• levenshtein - Levenshtein distance and similarity metrics with customizable edit costs and Winkler-like bonus for common prefix.
• go-querystring - Go library for encoding structs into URL query strings.
• go-message - Streaming Go library for the Internet Message Format and mail messages.
• Go Chainable - .map().filter().reduce() in Go. (HN)
• hcledit - Go package to edit HCL configuration.
• SSE - Server Sent Events Client/Server Library for Go.
• GoFrame - Modular, powerful, high-performance and enterprise-class application development framework of Go.
• jsonrpc2 - JSON-RPC 2.0 implementation for Go.
• Pretty - Efficient JSON beautifier and compactor for Go.
• jsonenums - Tool to automate the creation of methods that satisfy the json.Marshaler and json.Unmarshaler interfaces.
• Objx - Go package for dealing with maps, slices, JSON and other data.
• Centrifuge - Real-time messaging library for Go with scalability in mind.
• Certstore - Go library for accessing user identities stored in platform certificate stores.
• walk - Walks io/fs filesystems using an iterator style.
• binarydist - Binary diff and patch.
• diff - Print differences between two Go values.
• restruct - Rich binary (de)serialization library for Go.
• hackpadfs - Extensible file system abstraction for Go. File systems, composable interfaces, and test suites.
• qsim - Go package that lets you build queueing system simulators.
• art - Adaptive Radix Tree (ART) implementation in Go.
• firebolt - Go framework for streaming ETL, observability data pipeline, and event processing apps.
• egoscale - Wrapper for the Exoscale public cloud API.
• Go-KMS-Wrapping - Go library for encrypting values through various KMS providers.
• Go Sigar - Go implementation of the Sigar API.
• JSONC - JSON with comments for Go.
• magex - Helper methods for Magefiles.
• bufpipe - Buffered IO pipe.
• BLAKE3 - Pure Go implementation of BLAKE3 with AVX2 and SSE4.1 acceleration.
• goconcurrentqueue - Go concurrent-safe, goroutine-safe, thread-safe queue.
• Henry - Collection of nice to have generic function and algorithms for slices, maps and channels.
• iter - Go implementation of C++ STL iterators and algorithms.
• Exponential Backoff - Exponential backoff algorithm in Go. Uses feedback to multiplicatively decrease the rate of some process, in order to gradually find an acceptable rate.
• Go Reflector - Go reflection simplified.
• sroar - 64-bit Roaring Bitmaps in Go.
• build-info-go - Go library, which allows generating build-info for a source code project.
• dd - Dump any data as valid syntax in Go.
• stack - Implements utilities to capture, manipulate, and format call stacks.
• hq - Happy little queue.
• routine - ThreadLocal for Go.
• Amigo - Experiment to radically reinvision the Go tools ecosystem.
• kdtree - k-d tree implementation in Go.
• go-graphviz - Go bindings for Graphviz.
• Skipfilter - Skip list of arbitrary elements that can be filtered using roaring bitmaps stored in an LRU cache.
• Graft - RAFT Election implementation in Go.
• gosaml2 - Pure Go implementation of SAML 2.0.
• webtransport-go - Implementation of the WebTransport protocol, based on quic-go.
• go-events - Implements a composable event distribution package for Go.
• go-version - Library for parsing and verifying versions and version constraints.
• falco - VCL parser and linter optimized for Fastly.
• goid - Programmatically retrieve the current goroutine's ID.
• goRBAC - Lightweight role-based access control implementation in Go.
• myago - Utilities for building distributed systems.
• gxjpath - XJPath for Go. An easy way to get values from the deeps of JSON structures.
• text - Miscellaneous functions for formatting text.
• Stream - Stream processing library based on Go 1.18+ Generics (parallel, pipeline, lazy).
• go-digest - Common digest package used across the container ecosystem.
• memoryfs - In-memory filesystem implementation of io/fs.FS.
• Omniparser - Native Go ETL streaming parser and transform library for CSV, JSON, XML, EDI, text, etc.
• validate - No reflection. no gencode. hierarchical and extendable. fairly fast. 100LOC. generics.
• fleep - File format determination package for Go.
• Koazee - StreamLike, Immutable, Lazy Loading and smart Go Library to deal with slices.
• Gcfg - Read INI-style configuration files into Go structs; supports user-defined types and subsections.
• radar - Help to debug nested function call and Trace current file/line.
• Sture - Collection of data structures based on Go 1.18+ Generics (Stack, Queue, Linked List, etc.).
• MessagePack - Easier, faster, but extendable MessagePack Serializer for Go.
• IceCream-Go - Go port of Python's IceCream. Makes print debugging a little sweeter.
• Go Data Structures - Port/build well known and commonly used data structures to Go.
• go-msgauth - Go library for DKIM, DMARC and Authentication-Results.
• Config - Lightweight yet powerful configuration manager for Go projects.
• Container - Lightweight yet powerful IoC dependency injection container for Go projects.
• onion - Layer based configuration for Go.
• Base36 - Base36 encoding and decoding, which is useful to represent large integers in a case-insensitive alphanumeric way.
• well - Go framework for well-behaving commands.
• go-saga - Saga pattern implementation in Go.
• go-jsonnet - Jsonnet in pure Go.
• Knative Common Packages
• streaming-runtime-go
• Splunk Distribution of OpenTelemetry Go
• H3-Go - Go bindings for H3, a hierarchical hexagonal geospatial indexing system.
• Go FFmpeg Bindings
• Go Gumroad - Easily check licenses against Gumroad's API.
• libcnb - Language binding for the Cloud Native Buildpack Buildpack and Extension specifications.
• Pixlet - Build apps for pixel-based displays.
• atomic - Go package for atomic file writing.
• dedup - Streaming Deduplication package for Go.
• readahead - Asynchronous read-ahead for Go readers.
• go-dataloader - Clean, safe, user-friendly dataloader, written in Go with generics.
• replaylog - Type safe implementation of an op replay log.
• csvparser - Fast, easy-of-use and dependency free custom mapping from .csv data into Go structs.
• Sparse Merkle Tree - Performance oriented implementation of a binary SMT with parallel update, node batching and storage shortcuts.
• packit - Provides primitives for implementing a Cloud Native Buildpack according to the specification.
• go-multiaddr - Composable and future-proof network addresses.
• Go-Attestation - Abstracts remote attestation operations across a variety of platforms and TPMs, enabling remote validation of machine identity and state.
• Go-TPM - Go library that communicates directly with a TPM device.
• packageurl-go - Go implementation of the package url spec.
• DefSec - Set of tools for scanning IaC and configuration files.
• Gotext - GNU gettext utilities for Go.
• yyjson-go - Go port of yyjson, A high performance JSON library.
• GOMAD - Lightweight functional data and side effects manipulation patterns in Go with no dependencies.
• Song2 - Fast Gaussian Blur in Go.
• recursive fs - Recursive io/fs file system package.
• Rig - Go package for multi-protocol and multi-os remote host communication.
• xor - Implements XOR operations on byte slices.
• gust - Go ergonomic declarative generics module inspired by Rust.
• goutil - Go common tool functions and components.
• go-tagexpr - Interesting go struct tag expression syntax for field validation, etc.
• logtags - Key/value annotations for Go contexts.
• protoscan - Low-level reader for protocol buffers encoded data in Go.
• Garr - Collection of high performance, thread-safe, lock-free go data structures.
• go-libjpeg - Go binding for LibJpeg.
• tracing-go - Pragmatic and minimalistic module for collecting and exporting trace data from the Go code.
• go-rampart - Determine how intervals relate to each other.
• Tokenizer - Tokenizer (lexer) for Go.
• pipe - Simple and somewhat idiomatic way of constructing easy-to-glance-at pipes for sequential processes.
• Pion RTCP - Go implementation of RTCP.
• Debme - embed.FS wrapper providing additional functionality.
• Slicer - Utility class for handling slices.
• Go ANSI Parser - Converts strings with ANSI escape codes into a slice of structs that represent styled text.
• go-mp4 - Go library for reading and writing MP4.
• xstrings - Implements string functions widely used in other languages but absent in Go.
• go-bitfield - Simple bitfield package that's about 2-3x faster than using big.Ints from the standard library.
• semver for Go - Semantic Versioning (semver) library written in Go.
• goprocess - Like Context, but with good close semantics.
• nursery - Structured Concurrency in Go.
• fp-go - Collection of Functional Programming helpers powered by Go 1.18+ generics.
• Underscore - Useful functional programming helpers for Go 1.18 and beyond.
• Conflux Go API
• go-find - Programmatically accessible Go implementation of the *nix find command.
• ZenQ - Thread-safe queue faster than Go's native channels.
• fasthash - Go package porting the standard hashing algorithms to a more efficient implementation.
• SegmentIO Go generic data structures
• Honeypot - Lightweight event collection system.
• sdf - Go library for signed distance function shape generation.
• Huego - Extensive Philips Hue client library for Go with an emphasis on simplicity.
• gcon - Simple library to add async/await to Go using generics and closures.
• Go Time - Go supplementary time packages.
• dig - Reflection based dependency injection toolkit for Go.
• pool - Go library for common concurrency patterns using generics.
• Netlify Commons - Core library that will add common features for our services.
• Grule-Rule-Engine - Rule engine implementation in Go.
• Go Immutable Radix - Immutable radix tree implementation in Go.
• go-monads - Implements basic Haskell monads.
• skipset - High-performance, scalable concurrent sorted set based on skip-list.
• pdqsort - Pattern-defeating quicksort in Go with generics.
• run - New way to execute commands in Go.
• lexmachine - Lexical Analysis Framework for Go.
• roaring - Roaring bitmaps in Go.
• Quamina - Fast pattern-matching library.
• notificator - Desktop notifications with Go.
• workerpool - Worker pool library with auto-scaling, backpressure, and easy composability of pools into pipelines.
• xxHash - Pure Go implementation of xxHash.
• doublestar - Path pattern matching and globbing supporting doublestar (**) patterns.
• debounce - Debouncer written in Go.
• Parquet - Library for reading and writing parquet files.
• i18n - High-performant and powerful localization and internationalization support for Go.
• statik - Embed files into a Go executable.
• CBOR - Modern CBOR codec in Go.
• FlatBSON - Recursively flatten a Go struct using its BSON tags.
• socks5 - Go library about socks5, supports all socks5 commands.
• pctl - Industrial control systems in Go.
• Trie - Fast, zero heap allocation Go Trie for runes or paths.
• genh - Generics helpers.
• mo - Monads and popular FP abstractions, powered by Go 1.18+ Generics (Option, Result, Either...).
• workerpool - Lightweight and fast worker pool with generics support.
• sqlparser - Simple SQL parser meant for querying CSV files.
• Rita - Toolkit of various event-centric and reactive abstractions build on top of NATS.
• Circuit - Efficient and feature complete Hystrix like Go implementation of the circuit breaker pattern.
• WriterSeeker - In-memory io.WriteSeeker implementation missing in the standard lib.
• do - Dependency injection toolkit based on Go 1.18+ Generics.
• yaml - YAML marshaling and unmarshaling support for Go.
• Gosl - Go scientific library.
• Opt - Generic optional package for Go.
• Pion RTP - Go implementation of RTP.
• vcontext - Library for validating JSON and YAML configs in Go.
• Cmd - Non-blocking external commands in Go with and streaming output and concurrent-safe access.
• async-buffer - Generic Asynchronous data buffer with Automatic and Manual flushing.
• Tasqueue - Simple, customizable distributed job/worker in Go.
• Itogami - Fast and memory efficient thread-pool in Go.
• profiler - Simple wrapper over Go runtime/pprof for running multiple concurrent profiles and dumping results to files.
• trie - Trie implementation in Go meant for auto-completion use cases. Supports Levenshtein distance search.
• Validate - Generic Go data validate and filter tool library.
• rope - Persistent rope in Go.
• Spaniel - Time span handling for Go.
• Techan - Technical analysis library for Go.
• flume - Structured, leveled logging with global, runtime reconfiguration.
• goforit - Feature flags client library for Go.
• logf - Minimal logging library for Go.
• tstruct - Generate template FuncMap helpers to construct struct literals within a Go template.
• EGo - Framework for building confidential apps in Go.
• go-nanoid - Nano ID in Go -- very fast and efficient ID generator.
• skipmap - High-performance, scalable concurrent sorted map based on skip-list. Up to 10x faster than sync.Map in the typical pattern.
• Twilio Go - Go package for communicating with the Twilio API.
• Filter - Filtering, sanitizing, and conversion of Go data.
• Art - Adaptive Radix Tree done right.
• typesense-go - Go client for the Typesense API.
• slice_map - Designed to improve the performance for the case that you need to hold a large map in memory.
• reactor-go - Go implementation for reactive-streams.
• RSocket-go
• xunsafe - Faster Go reflection.
• Toolbox - Go utility library.
• Trie - Prefix tree implementation in go.
• Go Cache - Cache implementations in Go, with support for generics.
• Repeater - Go library for creating repeating function calls.
• Wastebasket - Go library allowing you to move files into your trashbin.
• fig - Minimalist Go configuration library.
• graph - Generic library for creating graph data structures and performing operations on them.
• cpy3 - Go bindings to the CPython-3 API.
• py4go - Tight bidirectional integration between Go and Python.
• Marshmallow - JSON unmarshalling library for flexible use cases like some known and some unknown fields, or prevention of data loss. (Reddit)
• filclient - Standalone client library for interacting with the filecoin storage network.
• Liquid - Liquid template engine in Go.
• lrmr - Online MapReduce framework for Go, which is capable for jobs in sub-second.
• fsync - Keeps files or directories in sync.
• QuickJS-Go - Go bindings to QuickJS: a fast, small, and embeddable ES2020 JavaScript interpreter.
• lockfree - Lock-free utilities in Go.
• Wordclouds - Wordclouds in go.
• recloser - Concurrent circuit breaker implemented with ring buffers.
• chris - Pratt parser implementation in Go.
• fastcgo - Fast (but unsafe) Cgo calls via an assembly trampoline.
• Paerser - Loads configuration from many sources.
• fast-fan-in - Go fan-in pattern efficiently adaptable to any channel type without code generation.
• reload - Simple managed reload mechanism for Go.
• grsync - Go rsync wrapper.
• Grafana Go regexp - Faster version of the Go regexp package.
• Go-generics - Generic slice, map, set, iterator, and goroutine utilities for Go.
• Imagemeta - Image Metadata (Exif and XMP) extraction for JPEG, HEIC, AVIF, TIFF and Camera Raw in Go.
• OpenFeature Go SDK
• compute-sdk-go - Go SDK for building Compute@Edge applications with TinyGo.
• Hotswap - Provides a solution for reloading your go code without restarting your server, interrupting or blocking any ongoing procedure.
• Deque - Highly optimized double-ended queue.
• JSON-RPC 2.0 - Go implementation of JSON-RPC 2.0 server with generics.
• Frugal - Very fast dynamic Thrift serializer & deserializer.
• smapping - Go struct generic mapping.
• Faker - Ultimate fake data generator for Go with zero dependencies.
• hotkey - Cross-platform hotkey package.
• timefmt-go - Efficient time formatting library (strftime, strptime) for Go.
• Unified Policy Engine
• go-async - Collection of utilities for async code in Go.
• PostHog Go - Official PostHog Go library.
• TinyGo Lunatic - TinyGo bindings for Lunatic.
• libngrok-go - Ngrok agent in library form, suitable for integrating directly into your Go application.
• go-set - Go package for sets implemented with generics.
• go-events - Simple EventEmmiter for Go. Inspired by NodeJS EventEmitter.
• metrics - Lightweight package for exporting metrics in Prometheus format.
• GoFreeDB - Go library that provides common and simple database abstractions on top of Google Sheets.
• core - Set of core packages every Go project needs. Minimal API, strictly versioned and with ~no dependencies.
• Go-SelfUpdate - Self-Update library for GitHub/Gitea hosted applications in Go.
• Gomme - Parser combinator library for Go.
• go-htmltable - HTML table data extractor for Go.
• gengo - Package for generating things based on go files.
• btrfs - Btrfs library in a pure Go.
• go-binarytree - Simple Binary Tree implementation in Go.
• go-syslog - Parser for Syslog messages and transports.
• Common - Go libraries shared across Prometheus components and libraries.
• Frisbee-Go - Go implementation of Frisbee - a bring-your-own protocol messaging framework designed for performance and stability.
• go-concurrency - Comprehensive support for complex concurrency requirements in Go.
• go-hostpool - Intelligently and flexibly pool among multiple hosts from your Go application.
• Opus - Pure Go implementation of the Opus audio codec. (Reddit)
• taskgroup - Go package for managing a group of collaborating goroutines.
• Shutdown - Manage shutdown code centrally, and provides functionality to execute code when a controlled shutdown occurs.
• simpex - Simpler and faster alternative to regexp.
• Gorgonia-Parser - Simple parser that turns a formulae written in unicode into an ExprGraph.
• Go-JSONRPC - Low Boilerplate JSON-RPC 2.0 library.
• Simpleflow - Generic simple workflows and concurrency patterns.
• GoParsec - Parser combinator library in Go.
• Go Parse - Parsec-like library for Go.
• tail - Go package for tail-ing files.
• pp - Colored pretty printer for Go.
• go-optional - Library that provides Go Generics friendly "optional" features.
• gowrtr - Library that supports Go code generation.
• go-reflect - Zero-allocation reflection library for Go.
• Unit - Conversion of unit library for Go.
• env - Lightweight package for loading environment variables into structs.
• nject - Go type-safe dependency injection.
• immcheck - Runtime immutability checks.
• Stream - Generic implementation for concurrency communication patterns.
• alog - Fully concurrent, non-IO blocking Logger for Go.
• Atomizer - Massively Parallel Distributed Computing.
• messagediff - Library for doing diffs of arbitrary Go structs.
• Threads Helper - Helper library for handling groups of threads easily.
• Jet - Template engine developed to be easy to use, powerful, dynamic, yet secure and very fast.
• atomic - Wrapper types for sync/atomic which enforce atomic access.
• check - Convenience helpers to perform validations of any kind.
• TOML - TOML parser for Go with reflection.
• Sorted Set - Data-struct inspired by the one from Redis. It allows fast access by key or score.
• Weave Common - Libraries used in multiple Weave projects.
• shellquote - Go utilities for performing shell-like word splitting/joining.
• Pipeline - Library to help you create pipelines in Go.
• Logger - Cross platform Go logging library.
• go-envparse - Minimal environment variable parser for Go.
• raggio - Go channels library.
• Matroska - Full-surface Go Wrapper for Haali's Matroska Parser.
• FFV1 Decoder in Go
• rxgo - Reactive programming in Go.
• Terraform Cloud/Enterprise Go Client
• Datadog Go - Library that provides a DogStatsD client in Go.
• Rgeo - Go package for basic, fast, local reverse geocoding.
• Go interface values - When storing a value in a Go interface allocates memory on the heap.
• Notify - Go-based assistance package that enables you to stream the output of several tools (or read from a file) and publish it to a variety of supported platforms.
• Goja-Node - Collection of Goja modules that provide Node compatibility.
• Go-NAT-PMP - Go language client for the NAT-PMP internet protocol for port mapping and discovering the external IP address of a firewall.
• GoUPnP - UPnP client library for Go.
• Hooks - Simple, type-safe hook system to enable easier modularization of your Go code.
• Noise - Go implementation of the Noise Protocol Framework.
• Bsimp - Minimalistic S3-backed audio library.
• Go-EXIF - Complete, highly tested, standards-driven (but customizable) EXIF reader/writer lovingly written in Go.
• pool - Go universal network connection pool.
• gopkg - Universal utility collection for Go, it complements offerings such as Boost, Better std, Cloud tools.
• artifex - Simple in-memory job queue for Go using worker-based dispatching.
• Tag - Parsing/editing tags ID3, MP4, FLAC.
• go-iprtb - Go implementation of the IP routing table.
• Unleash Go
• Frida-Go - Go bindings for Frida.
• RocketMQ Client Go
• Units - Go library that makes it easy to work with physical types, e.g. distances, velocities and angles.
• JSON Schema structures for Go - Go structures to marshal/unmarshal and reflect JSON Schema documents.
• getenv - Loading environment variables and parse them into go builtin types.
• VarInt - Fast & memory efficient arbitrary bit width integers in Go.
• Gogu - Comprehensive, reusable and efficient concurrent-safe utility functions and data structures library.
• Go FTP Server library
• Transport - Full stack, simple, fast, expandable application event bus.
• FSS3 - S3 filesystem abstraction layer for Go.
• Go-TypeScript - Compile and run Typescript code natively in Go.
• intintmap - Fast int64 -> int64 hash.
• fluent-logger-go - Structured logger for Fluentd.
• deepCopy - Makes deep copies of things: unexported field values are not copied.
• mergo - Merging Go structs and maps.
• Fn - Functional programming in Go.
• channel - Easy to use non-blocking unbounded buffered channel.
• QFrame - Immutable data frame that support filtering, aggregation and data manipulation.
• util-go - Terrastruct's general purpose go libraries.
• maphash - Hashing Go Types with AES Instructions.
• Go utilities
• low - Low level data type and utils in Go.
• rtreego - R-Tree library for Go.
• ping - ICMP Ping library for Go.
• Datadog Go client
• faker - Struct Data Fake Generator.
• goverter - Generate type-safe Go converters by simply defining an interface.
• Go Type Adapters - Type adapters for common Go protobuf messages.
• Signals - Simple, lightweight, and easy to use events library for Go.
• libdeflate - Go wrapper for the libdeflate library, supporting super fast zlib, gzip, and deflate compression, using cgo. Use case: in-memory, whole-buffered data.
• Transition - Go state machine implementation.
• Event Sourcing - Capture all changes to an application state as a sequence of events.
• QRCode - QR code, Micro QR code and Rectangular Micro QR Code (rMQR) encoder.
• conc - Better structured concurrency for go. (HN) (Building conc) (Lobsters)
• Top-K Heavykeeper - Top-K elephant flows finding using HeavyKeeper accurate algorithm.
• godebug - Pretty Printing for Go.
• midi - Library for reading and writing of MIDI messages and MIDI files (SMF) with Go.
• Box - Go package for wrapping value types.
• Highlight - Go package for syntax highlighting.
• Databricks SDK for Go
• gio-cloth - Desktop application for cloth physics simulation in Go.
• go-craq - Implements CRAQ (Chain Replication with Apportioned Queries).
• go-diff - Unified diff parser and printer for Go.
• go-dap - Go implementation of the Debug Adapter Protocol.
• gopherlogs - Simple, powerful, and extensible Go logging framework with batteries included.
• cadet - Library for creating simple HTTP-RPC servers in Go.
• jsonapi - Serializer/deserializer for JSON payloads that comply to the JSON API spec.
• Zen - Utility-first package for Go.
• Go-Wiki - Go Wikipedia API wrapper.
• curlreq - Creates *http.Request from curl command.
• goconfig - Lightweight on-the-fly configuration library for Go applications.
• goset - Fast and Safe Implementation of Set for Go.
• flagd - Feature flag daemon with a Unix philosophy.
• Holster - Mailgun's Go libraries and tools.
• gostream - Library to simplify the streaming of images as video and audio chunks to audio to a series of WebRTC peers.
• Maestro - Game server management service, designed to manage multiple game servers fleets in isolated schedulers.
• libvlc-go - Go bindings for libVLC and high-level media player interface.
• diff - Create, modify, and print diffs.
• Merkle - Efficient calculation of merkle roots and proofs.
• WardleyToGo - Create your WardleyMaps as code/data and render it as SVG.
• binstruct - Go binary decoder for mapping data into the structure.
• conv - Convert primitive types.
• OpenAPI Go - OpenAPI structures for Go.
• Bytemap - Types for making maps from bytes to bool, integer, or float using a backing array.
• pointy - Simple Go helper functions to provide a shorthand to get a pointer to a variable holding a constant.
• Hollywood - Blazingly fast and light-weight Actor engine written in Go.
• paths - Path finding library written in Go for use with games.
• mjml-go - Compile MJML to HTML directly in your Go applications.
• go-blurhash - Pure Go implementation of Blurhash.
• Go Promise - Introduces Promise feature from JavaScript in Go.
• Debugger Middleware - Debugging middleware for Go applications to enable better display of goroutines in the debugger.
• iomux - Unix domain network multiplexing for Go.
• selfupdate - Implements the standard client for the gokrazy Update System (GUS).
• starstruct - Starlark to Go struct converter.
• go-set - Generic set implementation for Go.
• go-slab - Slab allocator in go.
• nilable - Tiny Go generics library for making non-nilable values nilable.
• memorycache - Concurrent hashmap with ttl.
• tar-diff - Go library and set of command line tools to diff and patch tar files.
• otp - One time password for Go.
• Go Qdrant client
• form - Form Encoding & Decoding Package for Go.
• borsh-go - Go implementation of Binary Object Representation Serializer for Hashing.
• Workgroup - Generic Go library that provides a structured approach to concurrent programming. (Lobsters)
• semaphore - Fast resizable Go semaphore based on CAS.
• goption - Optional values for Go.
• opt - Simple and ergonomic optional type.
• purego - Library for calling C functions from Go without Cgo. (HN)
• gopatterns - Concurrency patterns in Go.
• MissingGo - Stuff that's missing in Go stdlib.
• currency - Handles currency amounts, provides currency information and formatting.
• Load Balancer Algorithms
• Go-wildcard - Fast and light wildcard pattern matching.
• Sonnet - High performance JSON decoder in Go.
• traffic - Thread safe load-balancer package for Go.
• Func - Knative Functions client API and CLI.
• Log - Minimal, colorful Go logging library.
• malgo - Go bindings for miniaudio library.
• Goldmark D2 - Goldmark extension for D2 diagrams.
• Go Text - Go libraries for text processing, many involving Unicode.
• Backoff - Simple exponential backoff counter in Go.
• JSON-RPC - Go implementation of JSON RPC 2.0 client over HTTP.
• OpenAI Go - Go wrapper for OpenAI Platform APIs.
• slices - Generic sort for slices in Go.
• IPLib - Library for working with IP addresses and networks in Go.
• JSON Logic - Implementation of JSON Logic in Go.
• openai-go - Go client libraries for OpenAI APIs.
• changelog - Parse markdown-esque changelogs (like our example), parse out versions, sections, changes & references.
• FastURL - Go URL parser using a Ragel state-machine.
• go-logger - Fast, lightweight, customizable and structured logger for Go.
• gotils - Go utilities to make your life easier with zero allocations.
• Go-DateParser - Easily parse localized dates in almost any string formats commonly found on web pages.
• Iterium - Generic Channel-based Iterators.
• combinations - Algorithm to generate all combinations out of a given string array.
• klevdb - Fast message store, written in Go. Think single partition on kafka, but stored locally.
• vault-client-go - HashiCorp Vault Go Client Library generated from OpenAPI spec.
• go-memdump - Very fast, very unsafe serialization for Go.
• go-restructure - Struct-based argument parsing.
• Utils - Non-Kubernetes-specific utility libraries which are consumed by multiple projects.
• Audioid - Fast and reliable audio tools.
• go-astisub - Go library to manipulate subtitles.
• smtppool - High throughput Go SMTP pool library with graceful handling of idle timeouts, errors, and retries.
• slog - Back-end agnostic interface for structured logs.
• Siegfried - Signature-based file format identification.
• broadcast - Notification broadcaster in Go.
• zeropool - Zero-allocation type-safe pool for Go.
• SwissMap - Hash table adapated from the "SwissTable" family of hash tables from Abseil.
• wifi - WiFi daemon for connecting to WiFi networks (encrypted or unencrypted) with gokrazy.
• ujson - Fast and minimal JSON parser and transformer that works on unstructured JSON.
• Config Manager - Config and Secret management across multiple implementations in a uniform way.
• tint - slog.Handler that writes tinted logs.
• Editorconfig Core Go
• arch - Holds machine architecture information used by the Go toolchain.
• Tokenizer - Pure Go implementation of OpenAI's tiktoken tokenizer.
• gortsplib - RTSP 1.0 client and server library for Go.
• xslog - Extension handlers for the slog library.
• bpm - Library and tool for dealing with beats per second detection.
• Marshmallow - Flexible and performant JSON unmarshalling in Go.
• just - Collection of useful functions. Complete simple tasks faster.
• Outboxer - Library that implements the outboxer pattern in go.
• go-mask - Simple, customizable Go library for masking sensitive information.
• queue - Go package providing multiple queue implementations. Developed in a thread-safe generic way.
• uDiff - Micro Go diff library.
• ecs - Simple and generic ECS implementation in Go.
• nan - Zero allocation Nullable structures in one library with handy conversion functions, marshallers and unmarshallers.
• typesetting - High quality text shaping in pure Go.
• x - Charm experimental packages.
• Relax - Start and finish your Go apps gracefully, even in the case of panics.
• clam - Templated shell helper library.
• IP2Location Go
• stackblur-go - Fast, almost Gaussian Blur implementation in Go.
• slog - Minimal structured logging library for Go.
• thp - High throughput primitives library.
• few - Fastest Encoder in the West.
• go-re2 - Drop-in replacement for regexp using re2, for any Go app.
• securecookie - Fast, secure and efficient secure cookie encoder/decoder.
• Starlight - Go wrapper for google's starlark embedded python language.
• useragent - Go parser for user agent strings.
• mirror - Use right mirror functions for string/[]byte performance bust.
• versioninfo - Importable package that parses version info from debug.ReadBuildInfo().
• timex - Go package for working with date.
• Speculator - Library for reconstructing OpenAPI specification from traffic of HTTP transactions.
• httpx - Better net/http for Go.
• Delta Go - Native Delta Lake Implementation in Go.
• Audio - Audio support for Go language.
• config - Declarative configuration for Go.
• TypeID - Type-safe, K-sortable, globally unique identifier inspired by Stripe IDs. (HN)
• diff - Go difference algorithm.
• Replicate Go client
• Flowmatic - Structured concurrency made easy.
• glob - Glob pattern matching.
• mp3binder - Concatenating, joining, binding MP3 files without re-encoding.
• opentelemetry-mapping-go - Go modules that implement OpenTelemetry-to-Datadog mapping for all telemetry signals.
• go-snowflake - Lock Free ID Generator for Go based on Snowflake Algorithm.
• Go Sync - Go library for synchronising all the things.
• cmd-stream-go - High-performance RCE library for Go.
• Concurrent Swiss Map - High-performance, thread-safe generic concurrent hash map implementation with Swiss Map.
• Pipeline - Go pipeline solution that can be used in many different combinations for chaining pipeline steps.
• periph - Peripherals I/O in Go.
• tsreflect - Flexible reflection based TypeScript type generator for Go types that can be marshalled with encoding/json.
• Go Util - Useful utils package for Go.
• Fp-go - Functional Programming Library for Go. (HN)
• go-fsevents - Recursive filesystem event watcher using inotify in Go.
• x - Extension of Go standard library.
• Sqids Go - Generate short YouTube-looking IDs from numbers.
• devslog - slog.Handler for developing code.
• enum - Type safe enums for Go without code generation. (Reddit) (Lobsters)
• Easymutex - Trivial mutex wrapper that allows you to unlock only once.
• go-ytdlp - yt-dlp cli bindings for Go.
• slog - Design workflows of slog handlers: pipeline, middleware, fanout, routing, failover, load balancing.
• timea.go - Simple library to print given times in "time ago" manner.

Links ​

• pkg.go.dev - Website for discovering and evaluating Go packages and modules. (Code)
• GoDoc.org - Hosts documentation for Go packages. Not maintained. (Code)
• GoDocs.io - Hosts documentation for Go packages. Maintained. (Code) (godocs.io one year later) (HN)
• Awesome Go
• Golang Serializer Benchmark Comparison
• gomodctl - Search, Check and Update Go modules.
• List of Go GUI/graphics/image related projects
• Go web framework benchmark
• Modu - Deadly simple terminal UI tool to update Go Modules.
• Collect data about your Go dependencies
• glice - Go license and dependency checker.
• gopkgs - Tool to get list available Go packages.
• GoCover.io - See code coverage of any Go package. (Code)
• gographs - Renders dependency graphs for Go packages. (Code)
• GoImportDot - Tiny tool to draw a graph of Go package import relationship.
• Wrapcheck - Go linter to check that errors from external packages are wrapped.
• gomajor - Go tool for major version upgrades.
• genv - Go imitation of Python's venv module.
• Vend - Small command line utility for fully vendoring module dependencies.
• Which Go router should I use? (2021) (Lobsters)
• Bingo - Missing package manager for Go binaries (its homebrew for "go install"). (HN)
• doc - Query Go module documentation.
• Dr-Docso - Go documentation bot for Discord.
• Exploring Go net/http Package - On How Not To Set Socket Options (2021)
• Cap'n Proto bindings for Go
• Go net/http.ServeMux and Trailing Slashes (2021) (Lobsters)
• Mod - Command line tool to upgrade/downgrade Semantic Import Versioning in Go Modules.
• Examples for dealing with the reflect package
• vgo2nix - Convert go.mod files to nixpkgs buildGoPackage compatible deps.nix files.
• go-structurizr - Library for auto-generating C4 diagrams from Golang applications.
• modvendor - Auxiliary vendoring tool for Go's new go.mod.
• interfaces - Code generation tools for Go's interfaces.
• A Closer Look at Go’s sync Package (2019)
• Recommendation for Key/Value storage in Go
• gomarkdoc - Generate markdown documentation for Go code.
• goesgen - Go code generator for event-sourced systems.
• gocap - List your dependencies capabilities and monitor if updates require more capabilities.
• Go Clean template - Clean Architecture template for Go services.
• Go generics the hard way - Hands-on approach to getting started with Go generics.
• GoDynamic - Load and unload dynamic library.
• Sage - Make-like build tool for Go projects.
• gocovsh - CLI viewer of Go test coverage reports.
• GoWrap - Command line tool that generates decorators for Go interface types using simple templates.
• How I write HTTP services after eight years (2018) (Reddit)
• go generics for the busy gopher (2022) (Reddit)
• Different Ways to Initialize Go structs (2022) (Reddit)
• The other sync package (2021)
• Pagoda - Rapid, easy full-stack web development starter kit in Go.
• ogen - Powerful and fast OpenAPI v3 code generator for Go. (Docs Code)
• godoc2md - Creates a markdown representation of a package's godoc.
• godoc2md - Simple translation from godoc to markdown.
• gosimports - Simpler goimports.
• c-for-go - Automatic C-Go Bindings Generator for Go.
• Are ORMs considered an anti-pattern in Go? (2022)
• Making the command line glamorous with Charm (2022)
• Bubbletea-Starter
• Go Starter - Opinionated production-ready SQL-/Swagger-first RESTful JSON API written in Go, highly integrated with VSCode DevContainers.
• Speeding up Go's builtin JSON encoder up to 55% for large arrays of objects (2022)
• SQL Query Strategy for complex structs (2022)
• Tygo - Generate Typescript types from Go source code.
• gochecknoinits - Check that no inits functions are present in Go code.
• Building Rich CLI Applications with Go's Built-in Templating (2022) (Reddit)
• How to write documentation for a private Go project? (2022)
• Log Analysis with netgo (2022)
• godocdown - Generates Go documentation in a GitHub-friendly Markdown format.
• Go streams (2022) (Reddit)
• Go Web Dev Examples
• Learn Go with Tests – Generics
• Awesome Go Repositories Twitter
• ART: Building a Prefix Search Trie in Go (2022)
• Hacking sum types with Go generics (2022) (HN)
• supply-chain-example - GoReleaser + Go Mod proxying + Cosign keyless signing + Syft SBOM generation example.
• Modern Go Application - Go application boilerplate and example applying modern practices.
• How we used Go 1.18 generics when designing our Identifiers at Encore (2022) (Lobsters)
• GoPlantUML - PlantUML Class Diagram Generator for Go projects.
• vanity - Go vanity domain HTTP handler.
• Courtney - Coverage tool for Go.
• ifacemaker - Generate interfaces from structure methods.
• Code examples for learning
• Go mod's lesser known features (HN)
• Using Go for traditional Web application development examples (2022)
• Get familiar with workspaces (2022)
• gojson - Automatically generate Go struct definitions from example JSON.
• Tutorial: Create a Go module (Code)
• Generation of SLSA3+ provenance for Go binaries
• Structured configuration in Go (2022)
• How to install Go modules
• GoMajor - Go tool for major version upgrades.
• Go analysis support for CodeQL
• Notify - Dead simple Go library for sending notifications to various messaging services.
• Crimes with Go Generics (2022) (HN)
• Nice overview of go web frameworks / resources
• Making Faster B-Trees with Go Generics (2022) (HN) (Reddit)
• Go JSON Schema Reflection - Generate JSON Schemas from Go types.
• Taming SQL and ORMs with sqlc (2022)
• Charm’s meta configuration files - Includes nice GoReleaser config.
• Dependabot bundler - Bundle Dependabot PRs into a single PR for Go projects.
• gen - Type-driven code generation for Go.
• A gentle introduction to generics in Go (2022) (Reddit)
• Go Debug - Utilities and libraries for debugging Go programs.
• OpenTelemetry Auto-Instrumentation for Go
• Go code coverage to SVG treemap
• Go Standard library
• Golang Diaries: Generics (2022) (Lobsters) (HN)
• testscript, a hidden gem the Go team kept locked away (Lobsters)
• gomodguard - Allow and block list linter for direct Go module dependencies.
• libc - Porting libc from C to Go
• depu - Tool to check available updates of dependent packages in go.mod.
• Copygen - Go generator to copy values from type to type and fields from struct to struct (copier without reflection). Generate any code based on types.
• struct2ts - Generate Typescript classes/interfaces out of Go structs.
• mdox - Format your docs; autogenerate from flags or Go structs or even generate versioned website directly from markdown.
• Mostly automatic Go dependency updates with GitHub Actions (2022)
• Makego - Makefile setup for our Go projects.
• gody - Lightweight struct validator for Go.
• selfupdate - Build self-updating Go programs.
• Test parallelization in Go: Understanding the t.Parallel() method (2022)
• Nicer struct literals in Go templates (2022)
• How to use GoString in Go (2022)
• Go generics are not bad (2022) (HN)
• go-rocket-update - Easy to use and modular library to make self updating Go programs.
• Go News Twitter
• Calling Go Functions from Other Languages using C Shared Libraries
• nonamedreturns - Go linter to detect named returns.
• structscanner - Make it easy to write code that scans data into structs in safe and efficient manner.
• Magefiles: Stop on first error (2022)
• Go on Compute@Edge (Article)
• deptree - Show Go dependence like tree.
• Adding a standard iterator interface to Go?
• Shaving 40% off Google’s B-Tree Implementation with Go Generics (2022)
• The problem with Go’s default HTTP handlers (2022) (HN)
• DataViz - Build and Visualize data structures in Go.
• Clockwork - Go Application runtime inspection tool.
• Self-Recompiling Go Binaries
• Metaprogramming with Go - or how to build code generators that parse Go code
• Fuzzing Go APIs for SQL Injection (2022) (HN)
• go-coverage - Increase code coverage of Go projects.
• Template project for Go libraries
• tools.mod - Example for using a separate modules file to track tool dependencies in Go.
• How to convert []interface{} to a JSON object in Go
• Which framework and ORM should we choose?
• Adding a Bubbletea CLI Interface (2022)
• Which ORM framework are you using with Go, and why? (2022)
• Planning Go 1.20 cryptography work (2022) (HN)
• gta - Do transitive analysis to find packages whose dependencies have changed.
• Ent vs Bun (2022)
• A Complete Guide to Logging in Go with Zerolog (2022)
• sketch - Generate JSON (De)serializable Object From Go Schema.
• Depguard - Go linter that checks if package imports are in a list of acceptable packages.
• Migrating our monorepo seamlessly from Dep to Go Modules (2022)
• ORM vs SQL Builder in Go (2022)
• oa3 - Generates HTTP endpoint stubs and supporting models from OpenAPI 3 specs.
• Top Go ORMs - Most starred on GitHub.
• Go Vulnerability Management
• A consistent logging format for Go (2022)
• Top Go Web Frameworks, most starred on GitHub
• goimports-reviser - Right imports sorting & code formatting tool (goimports alternative).
• GoReleaser-Cross - Docker image for Go cross-compiling with CGO.
• nabaz - Test runner for the easily distracted.
• coredumpctl, delve and debug packages for Go (2022)
• All about the Go errors package (2022)
• Go Web App Anti-Patterns
• Go-Coffee-Shop - Practical event-driven microservices demo built with Go. Nomad, Consul Connect, Vault, and Terraform for deployment.
• Go Workspaces Explained in 5 Minutes
• Golang Standard Library Mind Map
• typex - Examine Go types and their transitive dependencies. Export results as TypeScript value objects (or types) declaration.
• Tutorial: Developing a RESTful API with Go, JSON Schema validation and OpenAPI docs (2022)
• Go HTTPS servers with TLS (2021)
• How to Setup an HTTPS enabled client in Go (2022)
• OSV-Scanner - Find existing vulnerabilities affecting your project's dependencies. (HN)
• Connecting to a PostgreSQL database with Go's database/sql package
• Best Go ORM that uses GraphQL and Postgres (2022)
• Go: Inside sync.Map — How does sync.Map work internally? (2021)
• Error wrapping in Go (2022)
• Go 1.20 Cryptography (2023) (HN)
• Template for Go services
• Go Backend Clean Architecture - Go Backend Clean Architecture project with Gin, MongoDB, JWT Authentication Middleware, Test, and Docker.
• String to Integer (atoi) in Go (2023)
• Designing Go Libraries (2022)
• Major standard library changes in Go 1.20 (2023) (HN) (Lobsters)
• s3cme - Template Go app repo with image build/publish pipelines, SBOM, and SLSA provenance using OIDC, KMS and Artifact Registry.
• Examples of nice Go APIs (2023)
• gotestiful - gotest made beautiful.
• Fearless CORS: a design philosophy for CORS middleware libraries (and a Go implementation) (2023)
• go-doudou - Lightweight Go Microservice Framework.
• Gobuild - Reproducible binaries for the Go module proxy.
• Structured logging in Go with slog (2023) (Lobsters)
• go-update - Simple tool to update go git projects.
• Partially-Implemented Interfaces in Go (2023) (Reddit)
• Jupiter Project Layout
• go test and parallelism (2023) (Lobsters)
• Policy on util packages (2023) (Lobsters)
• Are there any decent ORMs in Go? (2023)
• Automating boilerplate/scaffolding code with custom code generation in Go, with jen (2023)
• The power of single-method interfaces in Go (2023)
• Comprehensive Guide to Structured Logging in Go (2023)
• Planning Go 1.21 Cryptography Work (2023)
• What's your recommended router? chi, mux, something else? (2023)
• Buster - Go CI/CD package for Go packages.
• Go integration testing with courage and coverage (2023)
• PG advisory locks in Go with built-in hashes (2023)
• Go crypto/ecdh and the TPM (2023)
• Writing HTTP client middleware in Go (2022)
• Using a Go package in Python using Gopy (2023)
• sally - Tiny HTTP server for supporting custom Go import paths.
• Where do you look for Go packages? (2023)
• gotmplfmt - Formatter for Go HTML templates.
• Go Project Structure
• RFC: Go Generics in the Pulumi SDK
• Go: Tracing HTTP requests (2022)
• gonstructor - Command-line tool to generate a constructor for the struct.
• Enumall - Tool to automate the creation of all const values for given type (enum).
• Preview: ranging over functions in Go (2023) (Lobsters)
• The proposal to enhance Go's HTTP router (2023) (Reddit) (Lobsters)
• Haunting Down Errors in Go (2023)
• Debug Go Request Latency with Datadog's Profiling Timeline (2023)
• Proposals for iterator-related functions in the Go standard library (2023)
• Iterators in Go (HN)
• Writing Clean Functions in Go with the Full Mapping Strategy (2023)
• Go plugins (2022)
• sqlclosecheck - Linter that confirms that DB rows and stats are closed properly.
• slogtest (2023)
• Scripting with Go: A Modest Proposal (2023) (HN) (Lobsters)
• Introduction to bufio package in Go (2017)
• Structured Logging with slog (2023) (HN)
• Go 1.22's (likely) new reflect.TypeFor() generic function (2023) (Lobsters)
• Why to prefer t.Cleanup to defer in tests with subtests using t.Parallel (2023)
• Dealing with large structs in (table) tests (2023) (Lobsters)
• enjargo - another way to generate go json encoders (2023)
• Introduction to CORS for Go programmers (2023)