Go
Actor Model
Graph control flow library (AOP, actor, state-machine).
An actor-based Framework with network transparency for creating event-driven architecture in Golang. Inspired by Erlang.
Artificial Intelligence
Embeddable vector database for Go with Chroma-like interface and zero third-party dependencies. In-memory with optional persistence.
Go SDK for building AI applications. One SDK, 20+ providers. Inspired by Vercel AI SDK.
AI Agent runtime engine with long-lived sessions for Claude Code, OpenCode, pi-mono and other CLI AI tools. Provides full-duplex streaming, multi-platform integrations, and secure sandbox.
LangChainGo is a framework for developing applications powered by language models.
A Go library for building stateful, multi-actor applications with LLMs, built on the concept of LangGraph，with a lot of builtin Agent architectures.
AI gateway for routing, securing, and monitoring LLM traffic across 10+ providers. OpenAI-compatible API, WASM policy plugins, canary rollouts, real-time dashboard.
AI Agent execution runtime with event sourcing, checkpoint recovery, and At-Most-Once execution guarantee. Written in Go.
Go SDK for building durable AI agents on Temporal with support for tools, MCP, human approvals, and sub-agent delegation.
A Go toolkit for building AI agents and applications across multiple providers with unified LLM, embeddings, tool calling, and MCP integration.
Local compatibility proxy for the Gemini and OpenAI APIs. Run one container locally and test both SDK protocol shapes on the same port without API keys or network access.
Audio and Music
Authentication and Authorization
Modular authentication system for the web. It tries to remove as much boilerplate and "hard things" as possible so that each time you start a new web project in Go, you can plug it in, configure it, and start building your app without having to build an authentication system each time.
A lightweight OAuth 2.0 Authorization Server supporting Device Authorization Grant (RFC 8628), Authorization Code Flow with PKCE (RFC 6749 + RFC 7636), and Client Credentials Grant for machine-to-machine authentication.
Authorization library that supports access control models like ACL, RBAC, and ABAC.
Utilities for GitHub authentication: generate and use GitHub application and installation tokens.
Go-Guardian is a golang library that provides a simple, clean, and idiomatic way to create powerful modern API and web authentication that supports LDAP, Basic, Bearer token, and Certificate based authentication.
Fairly complete implementation of the JOSE working group's JSON Web Token, JSON Web Signatures, and JSON Web Encryption specs.
JWT authentication package providing access tokens and refresh tokens with fingerprinting, Redis storage, and automatic refresh capabilities.
An open-source authentication and authorization server supporting OAuth2 and OpenID Connect.
chainable handlers for login with OAuth1 and OAuth2 authentication providers.
provides a lightweight role-based access control (RBAC) implementation in Golang.
This is quick session for net/http in GoLang. This package is perhaps the best implementation of the session mechanism, or at least it tries to become one.
provides a simple, clean, and idiomatic way to use OAuth and OAuth2. Handles multiple providers out of the box.
Simple, flexible, secure, and idiomatic web session management with pluggable backends.
A full featured implementation of JSON Web Tokens (JWT). This library supports the parsing and verification as well as the generation and signing of JWTs.
Go module implementing various JWx (JWA/JWE/JWK/JWS/JWT, otherwise known as JOSE) technologies.
Open Source (Go) implementation of "Zanzibar: Google's Consistent, Global Authorization System". Ships gRPC, REST APIs, newSQL, and an easy and granular permission language. Supports ACL, RBAC, and other access models.
JWT login microservice with pluggable backends such as OAuth2 (Github), htpasswd, osiam.
Successor of goauth2. Generic OAuth 2.0 package that comes with JWT, Google APIs, Compute Engine, and App Engine support.
Easy to use OpenID Connect client and server library written for Go and certified by the OpenID Foundation.
Implementation of fine-grained authorization based on the "Zanzibar: Google's Consistent, Global Authorization System" paper. Backed by CNCF.
Time-Based One-Time Password (TOTP) and HMAC-Based One-Time Password (HOTP) library for Go.
Library for keeping track of users, login states, and permissions. Uses secure cookies and bcrypt.
Go session management for web servers (including support for Google App Engine - GAE).
Dead simple, highly performant, highly customizable sessions service for go http servers.
Blockchain
A distributed, Byzantine fault-tolerant, deterministic state machine replication engine. It is a fork of Tendermint Core and implements the Tendermint consensus algorithm.
A Framework for Building Public Blockchains in the Cosmos Ecosystem.
A comprehensive smart contract suite built with Golang and Gnolang, a deterministic, purpose-built Go variant for blockchains.
A Go-based framework for building Polkadot/Substrate-compatible runtimes.
An IPFS implementation in Go. It provides content-addressable storage which can be used for decentralized storage in DApps. It is based on the IPFS protocol.
Local monitoring tool for a Cardano Node. It's a TUI (terminal user interface) designed to fit most screens.
Go library to interface with Solana JSON RPC and WebSocket interfaces.
Bot Building
Framework to build a bot for desired chat services including LINE, Slack, Gitter, and more.
Generated from official docs Go client library for accessing Telegram Bot API, with batteries for building complex bots included.
Ready to use Slack Bot for lazy developers: Custom commands, Jenkins, Jira, Bitbucket, Github...
Telegram Bot API library for Golang with full one-to-one API implementation.
Build Automation
Command Line
Advanced Console UIs
Go package to make lightweight ASCII line graph ╭┈╯ in command line apps with no other dependencies.
Dynamic configuration file templating tool for kubernetes manifest or general configuration files.
The non-invasive cross-platform terminal color library does not need to modify the Print method.
Go library that provides elegant and convenient style definitions using ANSI colors. Fully compatible & wraps the fmt library for nice terminal layouts.
Library for building a powerful interactive prompt, inspired by python-prompt-toolkit.
Terminal color rendering tool library, support 16 colors, 256 colors, RGB color rendering output, compatible with Windows.
Declaratively define styles for color, format and layout in the terminal.
High-performance TUI framework with Elm-inspired architecture, perfect Unicode rendering, and zero-allocation event system.
A library to beautify console output on every platform with many combinable components.
Termbox is a library for creating cross-platform text-based interfaces.
Go terminal dashboard based on termbox-go and inspired by blessed-contrib.
Standard CLI
Go library to split command line string as arguments array using the bash syntax.
Extends the standard flag package to support sub commands and more in idiomatic way.
A go library for configure and run command chains - such as pipelining in unix shells.
Dev-friendly CLI apps: sets up flags, defaults, and usage based on struct fields and tags.
Closed-loop application library for Cobra commands, with oh-my-posh prompts, and more.
Ultra-fast, zero-dependency, POSIX-compliant flag parsing library that can be used as drop-in stdlib replacement with security hardening.
Go option parser inspired by the flexibility of Perl’s GetOpt::Long.
A customizable line-editing library with Emacs keybindings, Unicode support, completion, and syntax highlighting. Used in NYAGOS shell.
A declarative, struct-tag based CLI framework for Go, with a broad feature set such as hierarchical commands/flags, i18n, shell completion, and validation.
Command line and flag parser supporting sub commands (superseded by kong; see below).
Feature-rich and easy to use command-line package based on golang struct tags.
Go library for building CLI applications with sophisticated flag and argument parsing and validation.
CLI framework with security hardening, plugin storage system, and production observability features.
Drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags.
Struct based flags generator for flag, urfave/cli, pflag, cobra, kingpin, and other libraries.
Eliminate Cobra boilerplate: build powerful, feature-rich CLIs declaratively from Go structs.
Another approach to parsing and running subcommands. Works alongside the standard flag package.
Simple, fast, and fun package for building command line apps in Go (formerly codegangsta/cli).
Collects and displays CLI version information in multiple formats along with upgrade notice.
Easy to use menu structure for cli applications that prompt users to make choices.
Configuration
File watching and configuration management with MPSC ring buffer, adaptive batching strategies, and universal format parsing (JSON, YAML, TOML, INI, HCL, Properties).
The configuration provider for consuming data in Azure App Configuration from Go applications.
Minimalistic configuration reader (from files, ENV, and wherever you want).
Cloud native application configuration. Bind ENV to structs in only two lines.
configure your app using file, environment variables, or flags in two lines of code.
Library for initializing configuration structs from env variables, files, flags and 'default' tag.
opinionated configuration loading & validation framework from ENV and Files focused towards 12-Factor compliant applications.
Structured data format to config struct decoder library for Go - supporting multiple data formats.
Library/tool to merge multiple JSON/YAML/TOML files from arbitrary URLs, validation against a JSON schema, and application of default values defined in the schema.
Container-oriented, zero-dependency configuration library that unifies Env variable and Flag parsing. Uses generics for type safety, without reflection or struct tags.
Yaml with environment variables reader. it helps to have secrets as environment variable but load them configs as structured Yaml.
Tiny library for reading configuration from a file and from environment variables (with validation & defaults).
Go package that fetches parameters from AWS System Manager - Parameter Store.
The library provides a unified way to read configuration data into a structure from various sources, such as env, flags, and configuration files (.json, .yaml, .toml, .env).
Simple library for application configuration based on annotated structs. It supports reading the configuration from environment variables, config files and command line parameters.
Go utility for loading configuration parameters from AWS SSM (Parameter Store).
A simple configuration library with recursive placeholders resolution and no magic.
Config manager with Struct Tags based contracts, custom value providers, parsers, and documentation generation. Customizable yet simple.
Populate Go structs from flags, environment variables, config.json and defaults with deterministic precedence. No extra dependencies.
Go port of Ruby's dotenv library (Loads environment variables from .env).
GoLobby Config is a lightweight yet powerful configuration manager for the Go programming language.
Tag-based configuration parser which loads values from different providers into typesafe struct.
application config manage(load,get,set). support JSON, YAML, TOML, INI, HCL. multi file load, data override merge.
Harvester, a easy to use static and dynamic configuration package supporting seeding, env vars and Consul integration.
Extensible, high-performance configuration management library, optimized for hierarchical data.
Human JSON, a configuration file format for humans. Relaxed syntax, fewer mistakes, more comments.
Configuration library for working with the HOCON(a human-friendly JSON superset) format, supports features like environment variables, referencing other values, comments and multiple files.
INI Parser & Write Library, Unmarshal to Struct, Marshal to Json, Write File, watch file.
Go library for managing configuration data from environment variables.
Light weight, extensible library for reading config in Go applications. Built in support for JSON, TOML, YAML, env, command line.
The simplest API for reading/watching config from file, env, flag and clouds (e.g. AWS, Azure, GCP).
Composable, observable and performant config handling for Go for the distributed processing era.
Command-line parser with support for arbitrarily complex command-line structures and additional sources of configuration such as YAML, JSON, TOML, etc (successor to kingpin).
Per-library struct-tag based configuration from command lines (Posix & Go-style); environment, JSON, YAML
Layer based configuration for Go, Supports JSON, TOML, YAML, properties, etcd, env, and encryption using PGP.
Instantiate/configure structs recursively, based on build environment. (YAML, TOML, JSON and env).
Continuous Integration
A minimal, local first continuous integration system that uses Docker to run jobs concurrently in stages.
Drone is a Continuous Integration platform built on Docker, written in Go.
A GitHub Action to track code coverage in your pull requests, with a beautiful HTML preview, for free.
CSS Preprocessors
Data Integration Frameworks
Data Structures and Algorithms
Bit-packing and Compression
Bit Sets
Bloom and Cuckoo Filters
Yet another Bloomfilter implementation in Go, compatible with Java's Guava library.
Probabilistic data structures for processing continuous, unbounded streams.
Cuckoo filter: a comprehensive cuckoo filter, which is configurable and space optimized compared with other implements, and all features mentioned in original paper are available.
Cuckoo filter: a good alternative to a counting bloom filter implemented in Go.
Data Structure and Algorithm Collections
Iterators
Maps
a thread-safe concurrent map for go, support using interface{} as key and auto scale up shards.
A high-performance, thread-safe generic concurrent hash map implementation with Swiss Map.
A persistent, map-like object for the Go programming language. Supports multiple embedded key-value stores.
Miscellaneous Data Structures and Algorithms
Combinatorial operations including permutations, combinations, and combinations-with-replacement.
Go implementation Count-Min-Log sketch: Approximately counting with approximate counters (Like Count-Min sketch but using less memory).
A comprehensive, reusable and efficient concurrent-safe generics utility functions and data structures library.
Nullable Types
Queues
Doubly-ended heap (min-max heap) with O(log n) access to both minimum and maximum elements.
Simple, in memory, zero dependency and battle tested, thread-safe deferred queue.
A generic, thread-safe doubly linked list with full iterator support and an intrusive singly linked list for embedded use; a feature-rich replacement for container/list.
Sets
Text Analysis
Go string comparison and edit distance algorithms library (Levenshtein, LCS, Hamming, Damerau levenshtein, Jaro-Winkler, etc.) compatible with Unicode.
Levenshtein distance and similarity metrics with customizable edit costs and Winkler-like bonus for common prefix.
Trees
Database
Caches
In-memory key:value cache which supports automatic invalidation based on timeouts.
BigCache with clustering support and individual item expiration.
Full implementation of Oracle Coherence cache API for Go applications using gRPC as network transport.
Embeddable Distributed in-memory data store compatible with Redis clients.
fast thread-safe inmemory cache for big number of entries. Minimizes GC overhead.
A pure non-intrusive cache library implemented by golang, you can use it to implement your own distributed cache.
A flexible multi-layer Go caching library to deal with in-memory and shared cache by adopting Cache-Aside pattern.
A GC-less, fast and generic LRU hashmap library with optional locking, sharding, eviction and expiration.
The generic version of GCache, cache support for expirable Cache, LFU, LRU and ARC.
A complete Go cache library with multiple stores (memory, memcache, redis, ...), chainable, loadable, metrics cache and more.
A data race free Go ache library with high performance and auto pruge functionality
Groupcache is a caching and cache-filling library, intended as a replacement for memcached in many cases.
A generic in-memory cache Go library. It supports expiration, sliding expiration, max entries limit, eviction callbacks and sharding.
A high performance lockless cache for Go. Many times faster than Ristretto and friends.
Pocache is a minimal cache package which focuses on a preemptive optimistic caching strategy.
A caching library with advanced concurrency features designed to make I/O heavy applications robust and highly performant.
Databases Implemented in Go
High-performance, columnar, embeddable in-memory store with bitmap indexing and transactions.
Personally identifiable information (PII) storage service built to comply with GDPR and CCPA.
An open-source, fast, reactive, in-memory database optimized for modern hardware. Higher throughput and lower median latencies, making it ideal for modern workloads.
Dependency-free, transactional graph database with REST API, phrase search and SQL-like query language.
A simple database management system that stores each table as a text file of line-delimited JSON.
immudb is a lightweight, high-speed immutable database for systems and applications written in Go.
LibraDB is a simple database with less than 1000 lines of code for learning.
LinDB is a scalable, high performance, high availability distributed time series database.
Milvus is a vector database for embedding management, analytics and search.
Native metadata service for distributed filesystems, object storage, and AI dataset workloads.
Nutsdb is a simple, fast, embeddable, persistent key/value store written in pure Go. It supports fully serializable transactions and many data structures such as list, set, sorted set.
An embedded k-v database based on LSM+WAL, supports string, list, hash, set, zset.
Fast timeseries database for IoT, realtime messaging applications. Access unitdb with pubsub over tcp or websocket using github.com/unit-io/unitd application.
A distributed high-performance key-value store. On Disk. Eventual consistent. HA. Able to grow or shrink without service interruption.
fast, resource-effective and scalable open source time series database. May be used as long-term remote storage for Prometheus. Supports PromQL.
Fast, embeddable, in-memory key/value database for Go with custom indexing and spatial support.
Lightweight columnar log analytics database with a pipe-style query language inspired by SPL.
Database Schema Migration
A Database Toolkit. A CLI designed to help companies better work with their data.
Discover SQL schemas and convert them to AVRO schemas. Query SQL records into AVRO bytes.
Django style fixtures for Golang's excellent built-in database/sql library.
Database migration manager, works with native query language. Support for cassandra, mysql, postgres, sqlite3.
Database migration tool. You can manage your database's evolution by creating incremental SQL or Go scripts.
Define your migrations separately in each library. Migrations for open source libraries. MySQL & PostgreSQL.
MySQL database migrator designed to run migrations to your features and manage database schema update with intuitive go code.
Library to embed schema migrations for database/sql-compatible databases inside your Go binaries.
Pure-SQL schema management system for MySQL, with support for sharding and external online schema change tools.
Database Tools
Collects small inserts and sends big requests to ClickHouse servers.
Database benchmarking tool with support for several databases and scripts.
Cloud-native database gateway and framework for building data-driven applications. Like API gateways, for databases.
High-performance SQL parser, formatter, linter, and security scanner with multi-dialect support and WASM playground.
Database backup from different drivers to different destinations with one command and configuration.
Simplify and accelerate development, instant, realtime, high-performance on any Postgres application, existing or new.
vitess provides servers and tools which facilitate scaling of MySQL databases for large scale web services.
SQL Query Builders
Go library that helps you keep sql files in one place and use them with ease.
Database Abstraction Layer (dbal) for go. Support SQL builder and get result easily.
Abstraction layer for PostgreSQL that supports advanced functionality and uses gorm-like syntax.
Framework for writing type-safe SQL queries in Go, with ability to easily convert database query result into desired arbitrary object structure.
Lightweight package containing some ORM-like features and helpers for sqlite databases.
Powerful data retrieval methods as well as DB-agnostic query building capabilities.
Powerful SQL Query builder that automatically generates SQL queries from structs.
Database Drivers
Interfaces to Multiple Backends
A simple key-value abstraction to store algebraic and linked-data data types at AWS storage services: AWS DynamoDB and AWS S3.
Relational Database Drivers
A Go client for rqlite, providing easy-to-use abstractions for working with the rqlite API.
This Go module is compatible with the database/sql driver. It allows embedding SQLite into your application, provides direct access to its C API, supports SQLite VFS, and also includes a GORM driver.
NoSQL Database Drivers
A Go Mongo library based on the official driver, featuring streamlined document operations, generic binding of structs to collections, built-in CRUD, aggregation, automated field updates, struct validation, hooks, and plugin-based programming.
Golang client for redislabs' ReJSON module using Redigo golang client. Store and manipulate structs as JSON objects in redis with ease.
A wrapper for the Google Cloud Platform Go Datastore package that adds caching using memcached.
A binary Memcached client for Go with support for sharding using consistent hashing, along with SASL.
Kivik provides a common Go and GopherJS client library for CouchDB, PouchDB, and similar databases.
(unmaintained) MongoDB driver for the Go language that implements a rich and well tested selection of features under a very simple API following standard Go idioms.
The MongoDB driver for Go. It‘s based on official MongoDB driver but easier to use like Mgo.
Search and Analytic Databases
Date and Time
A Duration extension supporting parsing/printing durations in days, weeks and years.
Simple Time extension with a lot of util methods, ported from PHP Carbon library.
Parses Cron-style time range expressions, checks if the given time is within any ranges.
Augments Time for working with dates, date ranges, time spans, periods, and time-of-day.
Set of functions to calculate public holidays in Germany, incl. specialization on the states of Germany (Bundesländer). Things like Easter, Pentecost, Thanksgiving...
Parse dates/times like "next dec 22nd at 3pm" and ranges like "from today until next thursday" without knowing the format in advance.
A comprehensive date utility library for Go, inspired by date-fns, with 140+ pure and immutable functions.
The implementation of the Persian (Solar Hijri) Calendar in Go (golang).
Convert string to duration. Support time.Duration returned string and more.
For interacting with intervals of time, defined as a start time and a duration.
Distributed Systems
More effective network communication, support two-way-calling, notify, broadcast.
Provides a minimal, modular and composable foundation for quickly developing services and more use case specific frameworks in Go.
Library for adding support for interacting and monitoring Celery workers, tasks and events in Go.
A feature complete and high performance multi-group Raft library in Go.
Provide efficient, stable and secure file distribution and image acceleration based on p2p technology to be the best practice and standard solution in cloud native architectures.
High performance, distributed, secure and low latency publish-subscribe platform built with MQTT, Websockets and love.
Fast and scalable distributed map/reduce system written in pure Go and Luajit, combining Go's high concurrency with Luajit's high performance, runs standalone or distributed.
Easy-to-Use scalable distributed big data processing, Map-Reduce, DAG execution, all in pure Go.
A gossip protocol and OpenAPI 3.0 spec based decentralized microservice framework. Built-in go-doudou cli focusing on low-code and rapid dev can power up your productivity.
A Go framework for the API or Microservice with handy scaffolding tools.
Microservice toolkit with support for service discovery, load balancing, pluggable transports, request tracking, etc.
A library built to provide support for defining async service health checks for golang services.
A web and rpc framework. It's born to ensure the stability of the busy sites with resilient design. Builtin goctl greatly improves the development productivity.
A high-performance and strong-extensibility Golang RPC framework that helps developers build microservices. If the performance and extensibility are the main concerns when you develop microservices, Kitex can be a good choice.
Fully spec compliant, embeddable high-performance MQTT v5/v3 broker for IoT, smarthome, and pubsub.
NATS is a simple, secure, and performant communications system for digital systems, services, and devices.
OpenTelemetry Compile-Time Instrumentation for Golang.
Lightweight library for the transactional outbox pattern in Go, not tied to any specific relational database or broker.
Framework for microservices with service discovery, load balancing, and related features.
Library for master-less p2p auto-discovery and RPC between HTTP services (using ZeroMQ).
A distributed development framework that integrates automatic code generation, gin and grpc frameworks, base development frameworks.
Framework for writing functions, microservices, or monoliths with WebAssembly
Dynamic DNS
Golang library for providing a canonical representation of email address.
Batteries-included IMAP client with auto-reconnect, OAuth2, IDLE support, and built-in MIME parsing.
Very simple package to send emails with SMTP Keep Alive and two timeouts: Connect and Send.
Mailx is a library that makes it easier to send email via SMTP. It is an enhancement of the golang standard library net/smtp.
Modern full-featured secure mail server for low-maintenance, self-hosted email.
Lightweight configurable multithreaded fake SMTP server. Mimic any SMTP behaviour for your test environment.
Embeddable Scripting Languages
Fast, portable, non-Turing complete expression evaluation with gradual typing.
A simple embeddable scripting language which supports concurrent event processing.
Expression evaluation engine for Go: fast, non-Turing complete, dynamic typing, static typing.
Cross-platform Polyglot Runtime which supports NodeJS, JavaScript, TypeScript, Python, Ruby, C#, WebAssembly, Java, Cobol and more.
Go implementation of Starlark: Python-like language with deterministic evaluation and hermetic execution.
Error Handling
Error handling tools and best practices for Go libraries and applications.
A better way to handle, trace, and log errors in Go. Compatible with the standard error library and github.com/pkg/errors.
Hackable package that determines responsible source code for an error (and some other fast-debugging features). Pluggable to any logger in-place.
Drop-in replacement for the standard library errors package and github.com/pkg/errors. Provides various error handling primitives.
The most simple error wrapper with awesome performance and minimal memory overhead.
Drop-in replacement for builtin Go errors. This is a minimal error handling package with custom error types, user friendly messages, Unwrap & Is. With very easy to use and straightforward helper functions.
A feature rich error package with stack traces, composition of errors and more.
A simple utility package for exception handling with try-catch in Golang.
An ergonomic mechanism for wrapping errors in order to facilitate structured metadata and context for error values.
Go (golang) package for representing a list of errors as a single error.
File Handling
Compute message digest, like MD5, SHA256, SHA1, CRC or BLAKE2s, for large files.
Go bindings for ExifTool, the well-known library used to extract as much metadata as possible (EXIF, IPTC, ...) from files (pictures, PDF, office, ...).
A simple HTTP middleware to automatically handle all your file upload needs
Simple and reliable package for file operations like copy/move/diff/list on files, directories and symbolic links.
File system event notification library with simple API, similar to os/signal.
Package to allow one to concurrently go through a filesystem with ease.
Financial
A crypto trading bot framework written in Go. Including common crypto exchange API, standard indicators, back-testing and many built-in strategies.
Handles currency amounts, provides currency information and formatting.
Fast and precise serialization and arithmetic for small fixed-point decimals
Library of financial functions for time value of money (annuities), cash flow, interest rate conversions, bonds and depreciation calculations.
Module to fetch exchange rates, check VAT numbers via VIES and check IBAN bank account numbers.
Invoice and billing document framework. JSON Schema based. Automates tax calculations and validation, with tooling to convert into global formats.
Query OFX servers and/or parse the responses (with example command-line client).
Technical analysis library with advanced market analysis and trading strategies.
Embedded transactional database of accounts, running in multithreaded mode.
Forms
Checker helps validating user input through rules defined in struct tags or directly through functions.
Keeps user input in check. Trims, sanitizes & scrubs data based on struct tags.
Decodes url.Values into Go value(s) and Encodes Go value(s) into url.Values. Dual Array and Full map support.
Framework-agnostic library for parsing and validating form/JSON data which supports multipart forms and files.
Bind data to any Go value. Can use built-in and custom expression binding capabilities; supports data validation
Decode an HTTP request into a custom struct, including querystring, forms, HTTP headers, etc.
Functional
Collection of Functional Programming helpers powered by Golang 1.18+ generics.
Functional helpers library providing Map, Filter, Reduce and other stream operations on generic slices Go1.18+ with lazy evaluation and error handling mechanisms.
Useful collection of helpfully functional Go collection utilities.
Game Development
Build your own Game-Engine based on the Entity Component System concept in Golang.
Engo is an open-source 2D game engine written in Go. It follows the Entity-Component-System paradigm.
GPU application framework with windowing, input, and rendering built on WebGPU reduces 480+ lines of GPU code to ~20, zero CGO (GoGPU ecosystem: gg, ui, wgpu, naga).
Scalable game server engine, featuring space-entity framework and hot-swapping.
Lightweight, facility, high performance golang based game server framework.
Game engine for creating retro games for modern computers. Inspired by Pico-8 and powered by Ebitengine.
Scalable game server framework with clustering support and client libraries for iOS, Android, Unity and others through the C SDK.
Generators
Generate any code based on Go types, including type-to-type converters (copy code) without reflection by default.
Code generation tool providing generics, free-form macros, conditional compilation and HTML templating.
Geographic
geoserver Is a Go Package For Manipulating a GeoServer Instance via the GeoServer REST API.
Convert geojson to s2 cells & demonstrating some S2 geometry features on map.
simplesfeatures is a 2D geometry library that provides Go types that model geometries, as well as algorithms that operate on them.
Go Compilers
Goroutines
A safe way to execute functions asynchronously, recovering them in case of panic.
conc is your toolbelt for structured concurrency in go, making common tasks easier and safer.
Concurrency limiter with support for timeouts, dynamic priority and context cancellation of goroutines.
A concurrent toolkit to help execute funcs concurrently in an efficient and safe way. It supports specifying the overall timeout to avoid blocking and uses goroutine pool to improve efficiency.
A pool built around exec.Cmd that spins up a given number of processes in advance and attaches stdin and stdout to them when needed. Very similar to FastCGI or Apache Prefork MPM but works for any command.
Manage a pool of goroutines using this lightweight library with a simple API.
Inspired from Java Thread Pool, Go WorkerPool aims to control heavy Go Routines.
Go Concurrency Manager package limits the number of goroutines that allowed to run concurrently.
asynchronous simple function utilities, for managing execution of closures and callbacks.
Gowl is a process management and process monitoring tool at once. An infinite worker pool gives you the ability to control the pool and processes and monitor their status.
A process controller used to control the execution and return strategies of multiple goroutines.
Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive.
Drop-in alternative to sync/errgroup, limited to a pool of N worker goroutines.
Limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation.
routine is a ThreadLocal for go library. It encapsulates and provides some easy-to-use, non-competitive, high-performance goroutine context access interfaces, which can help you access coroutine context information more gracefully.
go routine control with context, support: Main, Go, Pool and some useful Executors.
Semaphore pattern implementation with timeout of lock/unlock operations based on channel and context.
Fast resizable semaphore implementation based on CAS (faster than channel-based semaphore implementations).
GUI
Package to create apps with GO, HTML and CSS. Supports: MacOS, Windows in progress.
A framework for building 2D and 3D apps that run on macOS, Windows, Linux, iOS, Android, and the web.
Cross-platform based on LCL(Native System UI Control Library) and CEF(Chromium Embedded Framework) (Windows/ macOS / Linux)
Cross platform native GUIs designed for Go based on Material Design. Supports: Linux, macOS, Windows, BSD, iOS and Android.
Go bindings for Sciter: the Embeddable HTML/CSS/script engine for modern desktop UI development. Cross platform.
GPU-accelerated GUI toolkit with 22 widgets, 3 design systems (Material, Fluent, Cupertino), reactive signals, and zero CGO (part of GoGPU ecosystem).
Qt binding for Go (support for Windows / macOS / Linux / Android / iOS / Sailfish OS / Raspberry Pi).
A unified graphical user experience toolkit for Go desktop applications. macOS, Windows, and Linux are supported.
Cross-platform webview window with simple two-way JavaScript bindings (Windows / macOS / Linux).
OSX library to notify about any (pluggable) activity on your machine.
Go Native cross-platform GUI system automation. Control the mouse, keyboard and other.
Cross platform Go library to place an icon and menu in the notification area.
Hardware
Images
An image proxy with changeable storage backends and image processing engines with focus on speed and resiliency.
Generate QR codes with personalized styles, allowing adjustments to color, block size, shape, and icons.
GPU-accelerated 2D rendering with Canvas-like API, zero CGO (part of GoGPU pure Go graphics ecosystem).
The imghdr module determines the type of image contained in a file for Go.
Tool & Go library for image manipulation (Merge, Crop, Resize, Watermark, Animate).
Scout is a standalone open source software solution for DIY video security.
Go tool for LSB steganography, capable of hiding any file within an image.
IoT (Internet of Things)
Project Eywa is essentially a connection manager that keeps track of connected devices.
Project Flogo is an Open Source Framework for IoT Edge Apps & Integration.
Gobot is a framework for robotics, physical computing, and the Internet of Things.
Job Scheduler
A simple crontab like scheduler that aims to offer a KISS approach to job scheduling.
Simple Cron library for go that can execute closures or functions at varying intervals, from once a second to once a year on a specific date and time. Primarily for web applications and long running daemons.
Job scheduler supporting standard cron expressions, custom descriptors, intervals, and task dependencies.
Define time-based tasks using a simple Go API and Gron’s scheduler will run them accordingly.
Cron expression parser, task runner and daemon consuming crontab like task list.
Smart and featureful cron job scheduler with job queuing and live monitoring built in.
JSON
Easy access to nested values in maps and slices. Works in combination with encoding/json and other packages that "Unmarshal" arbitrary data into Go data-types.
Contains primitives for marshaling/unmarshalling Unix timestamp/epoch to/from build-in time.Time type in JSON.
Fast JSON parser and validator for Go. No custom structs, no code generation, no reflection.
Go-JsonError is meant to allow us to easily create json response errors that follow the JsonApi spec.
Advanced JSON to Go struct conversion. Provides package that can parse multiple JSON documents and create struct to fit them all.
JSON library to expose simple handlers that lets you easily read and write json from various sources.