Skip to main content

Go libraries

Like Gin for web end points ((this is nice template)). 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.

CLI​

  • Clir - Simple and Clear CLI library. Dependency free.
  • Bubble Tea - Fun, functional and stateful way to build terminal apps. (Tutorial) (HN) (Template)
  • 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.
  • BubbleZone - Helper utility for BubbleTea, allowing easy mouse event tracking.
  • 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.

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.

Web​

  • 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.
  • 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.
  • Chi - Lightweight, idiomatic and composable router for building Go HTTP services.
  • 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.
  • 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)
  • 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)
  • Fiber Swagger - Fiber middleware to automatically generate RESTful API documentation with Swagger 2.0.
  • 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.

GraphQL​

Flag parsing​

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

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.

DB​

  • KissSQL - Simple and Powerful Go SQL Library.
  • Kvass - Personal key-value store. (HN)
  • BetterCache - Modern Caching System with Lightning Fast Full Text Search. (Reddit)
  • 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)
  • 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.
  • rueidis - Fast Go Redis RESP3 client that supports client side caching and auto pipelining.
  • 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.
  • 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

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.

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.

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.

GUI​

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.

Biology​

  • biostuff - Go packages for handling biological data.

Docker​

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.

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.

Apple​

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

Error​

  • 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.

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.
  • 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?)
  • Muon - Lightweight alternative to Electron written in Golang in about ~300 LoC, using Ultralight instead of Chromium.
  • 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)
  • 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)
  • 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.
  • 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.