Awesome Go 🚀

Lightweight, high performance messaging system for microservices, IoT, and cloud native systems.

Manage your golang vendor and vendored packages with ease. Inspired by tools like Maven, Bundler, and Pip.

Simple and clean Telegram bot client.

dependency tool for go, godep helps build packages reproducibly by fixing their dependencies.

A simple, semantic and developer-friendly golang package for datetime.

Dead simple, no frills Go cross compile tool.

Hand-crafted 2D game library in Go.

Library and command for making and extracting .zip and .tar.gz archives.

Build interactive and accessible prompts with full support for windows and posix terminals.

A chatbot built with an artificial neural network.

Library for text processing that supports tokenization, part-of-speech tagging, named-entity extraction, and more. English only.

A little e-book on Ethereum Development with Go.

Go library for implementing command-line interfaces.

Elegant generics for Go.

build tool for Go, with a focus on cross-compiling and packaging.

naive go bindings to the CPython C-API.

Go (Golang) Package For Atom That Adds Autocomplete, Formatting, Syntax Checking, Linting and Vetting.

Go Manager - bundle for go.

Framework to build REST/GraphQL API on top of databases with mostly configuration over code.

Intro to go for experienced programmers.

official trading and market-making bot for the [Stellar](https://www.stellar.org/) DEX. Works out-of-the-box, written in Golang, compatible with centralized exchanges and custom trading strategies.

A golang implementation of a console-based trading bot for cryptocurrency exchanges.

Visualize dependency trees of any package by analyzing imports.

An opinionated guideline to structure & develop a Go web application/service.

Scalable, fault-tolerant application-layer sharding for Go applications.

IRC, Slack & Telegram bot written in Go.

Binds form and JSON data from net/http Request to struct.

Simple dependency manager for Go (golang), inspired by Bundler.

Library for enabling asynchronous dependency health checks in your service.

Embeds files into Go programs and provides http.FileSystem interfaces to them.

Simple tool to embed files in go with focus on "customization" and ease to use.

High-performance web framework for Go, reaches top scores in Lighthouse.

3D engine for the Go language, works on Windows and Linux ([Harfang on Go.dev](https://github.com/harfang3d/harfang-go)).

Make Highly Customized Boxes for your CLI.

Library for keeping track of users, login states, and permissions. Uses secure cookies and bcrypt.

Persistent and flexible background jobs library.

Pure Go CSS Preprocessor.

Intuitive package for prettifying terminal/console output.

Golang to Haxe to CPP/CSharp/Java/JavaScript transpiler.

Package raw enables reading and writing data at the device driver level for a network interface.

Extract values from strings and fill your structs with nlp.

Open source Pusher server implementation compatible with Pusher client libraries written in GO.

Telegram bot server with API similar to net/http.

TCP tool for network performance and path monitoring, including socket statistics.

A caching library with advanced concurrency features designed to make I/O heavy applications robust and highly performant.

Convert C code to Go code.

Go package for mapping values to and from space-filling curves, such as Hilbert and Peano curves.

Lightweight configuration manager for Go.

Golf is a fast, simple and lightweight micro-web framework for Go. It comes with powerful features and has no dependencies other than the Go Standard Library.

Various tools/modules help for development.

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.

A file transfer system, support to manage files with http api, rpc call and ftp client.

Vendor Go dependencies.

Small configuration library for Go that parses environment variables, JSON files, and reloads automatically on SIGHUP.

A distributed transaction manager. Support XA, TCC, SAGA, Reliable Messages.

In-memory key:value store with expiration time, 0 dependencies, <100 LoC, 100% coverage.

Service oriented IRC bot using Redis and JSON for messaging.

Approximate histograms for data streams.

plugin that provides way for auto-loading of Golang SDK, dependency management and start build environment in Maven project infrastructure.

Larry 🐦 is a really simple Twitter bot generator that tweets random repositories from Github built in Go.

XQuery lets you extract data from HTML/XML documents using XPath expression.

Framework for writing Slack bots.

A simple crontab like scheduler that aims to offer a KISS approach to job scheduling.

One unified interface for multiple Payment Service Providers (PsP) to process online payment.

A universal interface for caching slow database queries (backed by redis, memcached, ristretto, or in-memory).

Collection of Go images, graphics, and art.

Simple but powerful command line option parsing library for Go supporting subcommand.

Small command line interface framework.

A small, powerful and flexible merge library.

Pure Golang Telegram Bot API wrapper, generated from swagger file, session-based router, and middleware.

Fast and convenient feature processing for low latency machine learning in Go.

Wrapper around `go` command for colorized `go build` output.

Contextual fmt inspired by bootstrap color classes.

Client for stock market, forex and crypto data from finnhub.io. Access real-time financial market data from 60+ stock exchanges, 10 forex brokers, and 15+ crypto exchanges.

A Discord bot for managing ephemeral roles based upon voice channel member presence.

Framework for building Telegram bots.

Builds and restarts a Go project when it crashes or some watched file changes.

Cross platform package that follows the [XDG Standard](https://specifications.freedesktop.org/basedir-spec/latest/).

Send packets over TCP and UDP. It can buffer messages and hot-swap connections if needed.

Neo4j REST Client in golang.

Print ASCII tables from command line utilities without the need to pass large sets of data to the API.

Library for adding support for interacting and monitoring Celery workers, tasks and events in Go.

Plug-and-play, parallel Go framework for NeuroEvolution of Augmenting Topologies (NEAT).

Go application configuration made easy.

Fast micro-framework designed to build REST APIs and web services in a fast and simple way.

Simple and convenient formatted stylized output fully compatible with fmt library.

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.

High performant & accurate currency computation package.

More "natural" feeling web framework.

Article spinning and spintax/spinning syntax engine, useful for A/B, testing pieces of text/articles and creating more natural conversations.

Another framework for building Slack bots.

Provides configuration through multiple sources, including JSON, flags and environment variables.

Modular email validator for syntax, disposable, smtp, etc... checking.

Simple Go [VK](https://vk.com) bot library.

Build and manage your Go applications out of GOPATH.

Console application that displays outdated packages.

2Q in-memory cache implementation.

Simple and lightweight provider which exhibits JWTs, supports login, password-reset (via mail) and user management.

Flags persisted in an ini-like config file.

Telegram Bot Exec Terminal Command.

Go library to simplify CLI workflow.

Golang package for parsing ini-style configuration files.

REST framework for quickly writing resource based services.

Package tga is a TARGA image format decoder/encoder.

A wrapper to turn the VSCode go extension into a language server supporting the language-server-protocol.

A CLI program to encrypt/decrypt [andOTP](https://github.com/andOTP/andOTP) files. Can be used as a library as well.

Go library for ANSI colour text in terminals.

Persistent, fast ordered map using tree heaps.

Bitcask is an embeddable, persistent and fast key-value (KV) database written in pure Go with predictable read/write performance, low latency and high throughput thanks to the bitcask on-disk layout (LSM+WAL).

ugo is slice toolbox with concise syntax for Go.

Simple API for creating interpreters and so much more.

Quizzes for your terminal.

Timestamp convert & compare tool.

Multiple-output, structured logging for Go with extensible logging outputs.

blanket is a tool that helps you catch functions which don't have direct unit tests in your Go packages.

Functions that operate on slices; like `package strings` but adapted to work with slices.

Package contextplus provide more easy to use functions for contexts.

Simplify working with AWS DynamoDB.

aptly is a Debian repository management tool.

OpenAPI 3.x parser.

Go Library to access statdns.com API, which is in turn RRDA API. DNS Queries over HTTP.

ProtonMail module for waybar/polybar/yabar/i3blocks.

An embeddable scripting array language.

Fast and Distributed Actor framework using protocol buffers as message for Golang

Distributed actors for Go, C#, and Java/Kotlin

LangChainGo is a framework for developing applications powered by language models

Open Source OpenAI alternative, self-host AI models

Run large language models locally

Manage, load-balance, and failover packs of Ollamas

Native Go FLAC encoder/decoder with support for FLAC streams

Native Go Audio Processing Library

Go module implementing various JWx (JWA/JWE/JWK/JWS/JWT, otherwise known as JOSE) technologies

A comprehensive smart contract suite built with Golang and Gnolang, a deterministic, purpose-built Go variant for blockchains

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

Lightweight library that handles RabbitMQ auto-reconnect and publishing retries. The library takes into account the need to re-declare entities in RabbitMQ after reconnection

Context aware i18n with a short and consise API, pluralization, interpolation, and `fs.FS` support. YAML locale definitions are based on [Rails i18n](https://guides.rubyonrails.org/i18n.html)

Query and update data structures using selectors from the command line. Comparable to jq/yq but supports JSON, YAML, TOML and XML with zero runtime dependencies

Entropy Password Generator with extensive command line arguments to generate random strings securely including digits, passwords, and passwords built using obscure dictionary words mixed with symbols and digits

Go HTTP Requests for Humans™

Native Go AAC bitstream parser

A low-level library to play sound on multiple platforms

Go bindings for the PortAudio audio I/O library

A Framework for Building Public Blockchains in the Cosmos Ecosystem

Pagser is a simple, extensible, configurable parse and deserialize html page to struct based on goquery and struct tags for golang crawler

Unofficial Dusupay payment gateway API Client for Go

Mongodb Pagination for official mongodb/mongo-go-driver package which supports both normal queries and Aggregation pipelines

A tool for developers to share terminal/tmux sessions securely over the web. It’s perfect for remote pair programming, accessing computers behind NATs/firewalls, remote debugging, and more

A full, open source zero trust overlay network. Including numerous SDKs for numerous languages such as [golang](https://github.com/openziti/sdk-golang) allowing you to embed zero trust principles directly into your applications. The [OpenZiti Test Kitchen](https://github.com/openziti-test-kitchen) has numerous examples to draw inspiration from including a [zero trust ssh client - zssh](https://github.com/openziti-test-kitchen/zssh)

ID3 decoding and encoding library for Go

Mini audio library

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

chainable handlers for login with OAuth1 and OAuth2 authentication providers

provides a lightweight role-based access control (RBAC) implementation in Golang

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

Lightweight JSON Web Token (JWT) library

JWT middleware for Golang http servers with many configuration options

Every grain of sand on earth has its own ID

JWT login microservice with pluggable backends such as OAuth2 (Github), htpasswd, osiam

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](https://www.cncf.io/)

Golang OAuth2 server library

Time-Based One-Time Password (TOTP) and HMAC-Based One-Time Password (HOTP) library for Go

Golang implementation of Platform-Agnostic Security Tokens (PASETO)

Easily Manage OAuth2 Scopes In Go

Session Manager for HTTP servers

Efficient secure cookie encoding/decoding

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

Simple, yet effective HTTP session management and identification package

Simple jwt generator and parser

A distributed, Byzantine fault-tolerant, deterministic state machine replication engine. It is a fork of Tendermint Core and implements the Tendermint consensus algorithm

NATS is a simple, secure, and performant communications system for digital systems, services, and devices

Go Sparse matrix formats for linear algebra supporting scientific and machine learning applications, compatible with gonum matrix libraries

Pretty-print Go structs with Laravel/Symfony-style dumps, full type info, colorized CLI output, cycle detection, and private field access

A Go implementation of the Polkadot Host

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

A complete implementation of a Lightning Network node

Go library to interface with Solana JSON RPC and WebSocket interfaces

Zero-dependencies Telegram Bot library with additional UI components

An elegant and concurrent library for Telegram Bots in Go

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

Library to write bots for twitch.tv chat

A Golang library to manipulate strings according to the word parsing rules of the UNIX Bourne shell

Ready to use Slack Bot for lazy developers: Custom commands, Jenkins, Jira, Bitbucket, Github..

Easy to use framework to create Slack bots

Telegram bot framework is written in Go

Telegram Bot API library for Golang with full one-to-one API implementation

A bot for Telegram, Mastodon, Slack, and other messaging platforms archives webpages

Command line tool to frictionlessly manage project-specific commands

Air - Live reload for Go apps

Simple application watcher for multiple programming languages

[Gradle](https://docs.gradle.org/)/[Maven](https://maven.apache.org/) like build tool for Go projects

Create build pipelines in Go

Mage is a make/rake-like build tool using Go

Modern Make

Go build a system with file watchers and live to reload. Run, build and watch file changes with custom paths

Concurrent task runner

Task runner with README.md defined tasks, executable markdown

Go package to make lightweight ASCII line graph ╭┈╯ in command line apps with no other dependencies

ANSI terminal colors that support fmt.Printf/Sprintf

An interactive table component for bubbletea

TUI components for bubbletea

Go framework to build terminal apps, based on The Elm Architecture

Simple tables in a terminal with Go

Go package to easily provide a terminal spinner with options

Lightweight MP3 decoder library

Go library that provides elegant and convenient style definitions using ANSI colors. Fully compatible & wraps the [fmt library](https://pkg.go.dev/fmt) for nice terminal layouts

Library for building a powerful interactive prompt, inspired by [python-prompt-toolkit](https://github.com/jonathanslenders/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

Easiest way to match and mark strings for colorful terminal outputs

Multi progress bar for terminal applications

Basic thread-safe progress bar that works in every OS

A library to beautify console output on every platform with many combinable components

A simple sitemap generator, with a little syntactic sugar

Sesh is a CLI that helps you create and manage tmux sessions quickly and easily using zoxide

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

Termbox is a library for creating cross-platform text-based interfaces

Go terminal dashboard based on **termbox-go** and inspired by [termui](https://github.com/gizak/termui)

Advanced ANSI style & color support for your terminal applications

Go terminal dashboard based on **termbox-go** and inspired by [blessed-contrib](https://github.com/yaronn/blessed-contrib)

Flexible library to render progress bars in terminal applications

Easy to use menu structure for cli applications that prompt users to make choices

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

graph-based computational library like Theano for Go that provides primitives for building various machine learning and neural network algorithms

Working efficiently with message streams. Building event driven applications, enabling event sourcing, RPC over messages, sagas. Can use conventional pub/sub implementations like Kafka or RabbitMQ, but also HTTP or MySQL binlog

Emojis for Go

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

Authorization library that supports access control models like ACL, RBAC, and ABAC

provides a parser of cookies.txt file format

Yet Another CLi Spinner package, for working with terminal spinners

Command line argument parser inspired by Python's argparse module

Command argument completion generator for spf13/cobra

Harvester, a easy to use static and dynamic configuration package supporting seeding, env vars and Consul integration

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

PocketBase is a realtime backend in 1 file consisting of embedded database (SQLite) with realtime subscriptions, built-in auth management and much more

Safe, simple, and fast JSON Web Tokens for Go

Successor of goauth2. Generic OAuth 2.0 package that comes with JWT, Google APIs, Compute Engine, and App Engine support

Alternative CLI with "human face", in spirit of Go command

Extends the standard `flag` package to support sub commands and more in idiomatic way

A POSIX/GNU style, getopt-like command-line UI Go library

Commander for modern Go CLI interactions

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

Write bash completions in Go + Go command bash completion

An expressive programming language and a versatile interactive shell

A modern, powerful, and robust URL shortener microservice with mysql support

Library to generate TOTP/HOTP codes

Library to handle X509 proxy certificates

A collection of flag argument types for Go's standard `flag` package

Struct-based argument parsing in Go

go command line option parser

Go option parser inspired by the flexibility of Perl’s GetOpt::Long

A blazingly fast JSON serializing & deserializing library

A pure non-intrusive cache library implemented by golang, you can use it to implement your own distributed cache

SQL query builder, fork of Squirrel with improved performance

A Go-based framework for building Polkadot/Substrate-compatible runtimes

Command line and flag parser supporting sub commands (superseded by `kong`; see below)

Go readline-like library for command-line interfaces

A minimal but very powerful cli library for Go

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

Unikernel Builder/Orchestrator

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

Go Library for Telegram bot api

simple "Make" alternative

Go library for rendering ANSI colored text templates in terminals

Simple and complete API for building command line interfaces in Go

Collects and displays CLI version information in multiple formats along with upgrade notice

FreeDesktop.org (xdg) Specs implemented in Go

BCL is a configuration language similar to HCL

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

Load configuration in cascade from multiple backends into a struct

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

Parse environment variables to Go structs (with defaults)

A lightweight package for loading environment variables into structs

An environment utility package with support for unmarshaling into structs

Read your configuration from environment variables

Helpers to manage environment variables

Tiny library for reading configuration from a file and from environment variables (with validation & defaults)

Read environment variables easily with dotenv support

A versatile ETL library that parses text input (CSV/txt/JSON/XML/EDI/X12/EDIFACT/etc) in streaming fashion and transforms data into JSON output using data-driven schema

Excel binding to struct written in Go.(Only supports Go1.18+)

Colorable writer for windows

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

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

Pure golang package for reading and writing xz-compressed files

Go library for color output in terminals

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

Viper wrapper with config inheritance and key generation

Simple mDNS (Multicast DNS) client/server library in Golang

isatty for golang

Lightweight, zero-dependency, and extendable configuration management

Go configuration with fangs

Go implementation of the [XDG Base Directory Specification](https://specifications.freedesktop.org/basedir-spec/latest/) and [XDG user directories](https://wiki.archlinux.org/index.php/XDG_user_directories)

The "safe subset" of YAML for Go configs

Fast, zero-allocation, lexicographical-order-preserving packing of native types to bytes

Go library that helps you build SQL queries

Minimalist Go library aimed at creating Console User Interfaces

Enterprise-Grade CI/CD and DevOps Automation Open Source Platform

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

Use Go 1.18's built-in fuzz testing in GitHub Actions

Automate the semantic versioning of Git repositories

Test, Build, Sign, and Publish your go binaries from a clean workspace

go test output for humans

Go integration for Coveralls.io continuous code coverage tracking system

Fast website link checker in Go, see [alternatives](https://github.com/lycheeverse/lychee#features)

Go package implementing buffers for handling various datatypes easily

Tool that reports coverage of files below set threshold

TUI for browsing, comparing, and editing .env files

Signal-based reactive components framework for building TUIs

Woodpecker is a community fork of the Drone CI system

A message streaming bridge between a range of protocols

A high-performance ELT data integration framework with pluggable architecture

A reflection based dependency injection toolkit for Go

Small library for terminal color based tables

Library for updating terminal output in real time

Go package implementing compressed bitsets

Dense, zero-allocation, SIMD-enabled bitmap/bitset in Go

Go package implementing bitsets

Go package implementing Bloom filters

Bloom filters implemented in Go

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

A flexible multi-layer Go caching library to deal with in-memory and shared cache by adopting Cache-Aside pattern

Language Detection API Go Client. Supports batch requests, short phrase or single word language detection

Simple, useful, and opinionated CLI package in Go

Go library to split command line string as arguments array using the bash syntax

Algorithms and data structures.CLRS study

Collection of useful, performant, and thread-safe data structures

Go Data Structures. Containers, Sets, Lists, Stacks, Maps, BidiMaps, Trees, HashSet etc

Data structure and algorithm library for go, designed to provide functions similar to C++ STL

Go implementation of C++ STL iterators and algorithms

a thread-safe concurrent map for go, support using `interface{}` as key and auto scale up shards

Python-like dictionaries (dict) for Go

A persistent, map-like object for the Go programming language. Supports multiple embedded key-value stores

Highly concurrent drop-in replacement for `bufio.Writer`

Multi-shell multi-command argument completer

Define simple completions using a spec file

Finite-State Machine package

Go 1.18+ generics package inspired by Kotlin's Sequence and Map

Generic slice, map, set, iterator, and goroutine utilities

Region quadtrees with efficient point location and neighbour finding

Generic tuple implementation for Go 1.18+

Go Data Structures using Go 1.18 generics

An easy to use, lightweight, thread-safe and append-only in-memory data structure inspired by Apache Kafka

A distributed high-performance key-value store. On Disk. Eventual consistent. HA. Able to grow or shrink without service interruption

A distributed systems development framework

An avatar generator for Go

A Simple and Clear CLI library. Dependency free

A simple command line notebook with multi-device sync

Implementation of dataframes, series, and data wrangling methods for Go

HyperLogLog implementation with Sparse, LogLog-Beta bias correction and TailCut space reduction

Multiple thread-safe, generic queue implementations for Go

Generate idiomatic Go code for databases based on existing schema definitions or custom queries supporting PostgreSQL, MySQL, SQLite, Oracle, and Microsoft SQL Server

Wi-Fi QR Code Generator

Tag-based environment configuration for structs

A robust and idiomatic flags package with excellent subcommand support

Go library for building command line applications

Zero allocation Nullable structures in one library with handy conversion functions, marshallers and unmarshallers

Null Types, Safe primitive type conversion and fetching value from complex structures

Fast ring-buffer deque (double-ended queue)

Concurrent FIFO queue

Runs a command in an acme win on file changes

Go library for implementing command-line interfaces

JOB, make your short-term command as a long-term job

Thread-Safe and Non-Thread-Safe high-performance sets for Go

A useful Set collection implementation for Go

Modern text indexing library for go

Go implementation of Adaptive Radix Tree

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

Implementation to calculate levenshtein distance in Go

Eventually consistent distributed in-memory cache Go library

Efficient key/value cache for gigabytes of data

fast, resource-effective and scalable open source time series database. May be used as long-term remote storage for Prometheus. Supports PromQL

Go language driver for Riak KV

Implementation of Rusts `dbg!` macro for quick and easy debugging during development

Library to create prompt chain

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)

An implementation of prefix tree

Split byte streams into chunks, and arrange chunks into trees, with boundaries determined by content, not position

Very fast Go Skiplist implementation

Kivik provides a common Go and GopherJS client library for CouchDB, PouchDB, and similar databases

Fast natural language detection package

Simple logging interface that supports cross-platform color and concurrency

Skiplist implementation in Go

Go module that processes work concurrently and returns output in a channel in the order of input

FIFO Pipeline which parallels execution on each stage while maintaining the order of messages and results

Simple, useful and opinionated config loader

A Go package that read or set data from map, slice or json

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

Cache library with support for expirable Cache, LFU, LRU and ARC

Functions to determine the natural language of a unicode text

Go package that fetches parameters from AWS System Manager - Parameter Store

A complete Go cache library with multiple stores (memory, memcache, redis, ...), chainable, loadable, metrics cache and more

Groupcache is a caching and cache-filling library, intended as a replacement for memcached in many cases

A High Performance, Generic, thread-safe, zero-dependency cache package

A generic in-memory cache Go library. It supports expiration, sliding expiration, max entries limit, eviction callbacks and sharding

A Go caching framework that supports multiple data source drivers

A high performance lockless cache for Go. Many times faster than Ristretto and friends

High performance, near optimal in-memory cache with proactive TTL expiration and generics

Map with expiring key-value pairs

An in-memory cache with item expiration and generics

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

Safe database schema change and version control for DevOps teams

Database schema evolution library for Go

Go bindings for the snowball libstemmer library including porter 2

A Go package that marshals and unmarshals INI-files

An embedded key/value database for Go

A lightweight document-oriented NoSQL database written in pure Golang

Scalable, Geo-Replicated, Transactional Datastore

Simple ACID key-value database that supports transactions

High-performance, columnar, embeddable in-memory store with bitmap indexing and transactions

CovenantSQL is a SQL database on blockchain

Scalable, Distributed, Low Latency, High Throughput Graph Database

Home-grown disk-backed key-value store

Dolt – It's Git for Data

Dependency-free, transactional graph database with REST API, phrase search and SQL-like query language

A Golang implemented high-performance Redis server and cluster

A lightweight, framework-agnostic database migration tool

MongoDB model-based ODM for Go (based on official MongoDB driver)

Sentiment analyzer using sentiwordnet lexicon in Go

Modular JSON configuration. Keep your config structs along with the code they configure and delegate parsing to submodules without sacrificing full config serialization

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

Scalable datastore for metrics, events, and real-time analytics

Ledisdb is a high performance NoSQL like Redis based on LevelDB

Levigo is a Go wrapper for LevelDB

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

Pure-SQL schema management system for MySQL, with support for sharding and external online schema change tools

Database migration tool. Allows embedding migrations into the application using go-bindata

Database migration generator. Allows generate sql migration from model and existing sql by differ them

Official MongoDB driver for the Go language

MySQL based distributed lock

Go package to read and write INI files

Milvus is a vector database for embedding management, analytics and search

Moss is a simple LSM key-value storage engine written in 100% Go

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

High-performance embedded Object Database (NoSQL) with Go API

RocksDB/LevelDB inspired key-value database in Go

Lightweight RESTful database engine based on stack data structures

Embedded key-value store for read-heavy workloads

Monitoring system and time series database

Fast and simple key/value store written using Go's standard library

An embedded k-v database based on LSM+WAL, supports string, list, hash, set, zset

A tiny Redis server built with Golang, compatible with RESP protocols

The lightweight, distributed, relational database built on SQLite

TiDB is a distributed SQL database. Inspired by the design of Google F1

Your NoSQL database powered by Golang

Fast timeseries database for IoT, realtime messaging applications. Access unitdb with pubsub over tcp or websocket using github.com/unit-io/unitd application

Go implementation of [VADER Sentiment Analysis](https://github.com/cjhutto/vaderSentiment)

Simple useful package for read environment variables

Minimalistic, zero dependency, typed environment variables library

A Go package to help write migrations with go-pg/pg

A Go package that encodes and decodes Avro data

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

Database schema migration helper for Gorm ORM

Define your migrations separately in each library. Migrations for open source libraries. MySQL & PostgreSQL

Database migrations. CLI and Golang library

Dead simple Go database migration library

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

Microservice implementation of [GoVader](https://github.com/jonreiter/govader)

Abstruse is a distributed CI platform

Collects small inserts and sends big requests to ClickHouse servers

Database benchmarking tool with support for several databases and scripts

A fast data generator that produces CSV files from generated relational data

Cloud-native database gateway and framework for building data-driven applications. Like API gateways, for databases

Go toolset to handle MySQL protocol and replication

Multi-tenancy support for GORM managed databases

Go package for sharding databases ( Supports every ORM or raw SQL )

Database backup from different drivers to different destinations with one command and configuration

Advanced scheduling for PostgreSQL

Web-based PostgreSQL database browser

Simplify and accelerate development, ⚡ instant, realtime, high-performance on any Postgres application, existing or new

Redis RDB file parser for secondary development and memory analysis

Golang implementation of the Paice/Husk Stemming Algorithm

Recursive coverage testing tool

A very simple CSS parser, written in Go

WeScale is a database proxy designed to enhance the scalability, performance, security, and resilience of your applications

Lightweight and easy to learn query builder

Go database query builder library for PostgreSQL

Zero boilerplate database operations for Go

Go library that helps you keep sql files in one place and use them with ease

Non-invasive SQL builder and powerful data binder

Fast SQL query builder

Go wrapper to the 100% Sass compatible libsass project

Binary packer and unpacker helps user build custom binary stream

Idiomatic SQL builder and query library

Secure your handcrafted SQL against injection

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

Tool that generates constants from files with raw SQL queries

A SQL Gen for generating standard SQLs(supports: CRUD) written in Go

Type-safe SQL builder and struct mapper for Go

A lightweight DSL to build SQL in Go

An enhanced http client with retry and hystrix capabilities

Golang set data structure with bonus bit-twiddling functions

Golang Bloom filter implementation

Datastore connectivity for SQL, NoSQL, structured files

A simple key-value abstraction to store algebraic and linked-data data types at AWS storage services: AWS DynamoDB and AWS S3

Transaction manager with multiple adapters (sql, sqlx, gorm, mongo, ...) controls transaction boundaries

Simple key-value store abstraction and implementations for Go (Redis, Consul, etcd, bbolt, BadgerDB, LevelDB, Memcached, DynamoDB, S3, PostgreSQL, MongoDB, CockroachDB and many more)

Datastore Connectivity for BigQuery for go

Firebird RDBMS SQL driver for Go

Microsoft ActiveX Object DataBase driver for go that uses database/sql

Microsoft MSSQL driver for Go

A decentralized identity-based social network

A library built to provide support for defining async service health checks for golang services

Go bindings for Lua C API

Yet another Bloomfilter implementation in Go, compatible with Java's Guava library

SQLite3 driver for go that uses database/sql

Oracle driver for Go, using the ODPI-C driver

Microsoft MSSQL driver. Go wrapper over [FreeTDS](https://www.freetds.org)

A Simple and Powerful Golang SQL Library

PostgreSQL driver supporting features beyond those exposed by database/sql

Simple [pgx](https://github.com/jackc/pgx) wrapper to execute and [scan](https://github.com/georgysavva/scany) query results easily

Pure Go Postgres driver for database/sql

SQLite with pure Go

Attach hooks to any database/sql driver

native and database/sql driver YDB (Yandex Database)

Aerospike client in Go language

Lightweight golang driver for ArangoDB

Datastore Connectivity for Aerospike for go

Go bindings for ForestDB

Simple, fast and scalable RPC library for high load

The Go language implementation of gRPC. HTTP/2 based RPC

Go implementation of a high performance, thread safe bloom filter

Iterator implementation to provide map and reduce functionalities

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

REST client and standard `database/sql` driver for Azure Cosmos DB

redis client implement by golang, inspired by jedis

A binary Memcached client for Go with support for sharding using consistent hashing, along with SASL

Go language driver for RethinkDB

Console tool for highlighted formatting and struct query fetching JSON

Resiliency patterns for golang

Go 1.18+ generic map interface for maps; safe maps; ordered maps; ordered, safe maps; etc

Combinatorial operations including permutations, combinations, and combinations-with-replacement

Neo4j client for Golang

Redigo is a Go client for the Redis database

Redis client for Golang

Fast Redis RESP3 client with auto pipelining and server-assisted client side caching

Typesafe, customizable, clean & easy to use Redis client

Elasticsearch client for Go

Convert sql to elasticsearch dsl in Go

Elasticsearch client library

Official Elasticsearch client for Go

C99-compatible strftime formatter

In-memory geo index

Determine how intervals relate to each other

A comprehensive, reusable and efficient concurrent-safe generics utility functions and data structures library

ID type with marshalling to/from hash to prevent sending IDs to clients

Simple Time extension with a lot of util methods, ported from PHP Carbon library

Augments Time for working with dates, date ranges, time spans, periods, and time-of-day

Parse date's without knowing format in advance

Scriptable interpreter written in Go

Generic, zero-alloc, 100%-test covered quadtree

Pure, generic functions for slices

Nullable Go types that can be marshalled/unmarshalled to/from JSON

The implementation of the Persian (Solar Hijri) Calendar in Go (golang)

Useful extensions (Timedelta, Strftime, ...) to the golang's time package

Go to Lua binding library, based on [gopher-lua](https://github.com/yuin/gopher-lua)

Go port of the Rapid Automatic Keyword Extraction Algorithm (RAKE)

A highly optimized double-ended queue

Disjoint Set data structure implementation in Go

Simple set data structure implementation in Go using LinkedHashMap

A Go package for working with dates

Now is a time toolkit for golang

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

gobrew lets you easily switch between multiple versions of go

Tools for parse JSON-like logs for collecting unique fields and events

Trie implementation in Go

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