go语言项目汇总
Indexes and search engines
These sites provide indexes and search engines for Go packages:
- awesome-go – A community curated list of high-quality resources.
- Awesome Go @LibHunt – Your go-to Go Toolbox.
- godoc.org – A documentation browser for any Go open source package.
- go-hardware – Curated list of resources for using Go on non-standard hardware.
- go-patterns – Commonly used patterns and idioms for Go.
- gopm.io – Download Go packages by version
- go-search – Search engine dedicated to Go projects and source.
- gowalker – API documentation generator and search.
- Golang Data Science – Curated list of data science libraries for Go.
- Go Report Card – Code quality summaries for any Go project.
- Sourcegraph – Source indexing, analysis and search.
Dead projects
If you find a project in this list that is dead or broken, please either mark it as such or mention it in the #go-nuts IRC channel.
Table of Contents
- Astronomy
- Build Tools
- Caching
- Cloud Computing
- Command-line Option Parsers
- Command-line Tools
- Compression
- Concurrency and Goroutines
- Configuration File Parsers
- Console User Interface
- Continuous Integration
- Cryptography
- Databases
- Data Processing
- Data Structures
- Date
- Development Tools
- Distributed/Grid Computing
- Documentation
- Editors
- Encodings and Character Sets
- Error handling
- File Systems
- Games
- GIS
- Go Implementations
- Graphics and Audio
- GUIs and Widget Toolkits
- Hardware
- Language and Linguistics
- Logging & Monitoring
- Machine Learning & AI
- Mathematics
- Microservices
- Miscellaneous
- Music
- Networking
- DNS
- FTP
- HTTP
- IMAP
- Instant Messaging
- NNTP
- Protocol Buffers
- rsync
- Telnet
- VNC
- Websockets
- ZeroMQ
- Misc Networking
- Operating System Interfaces
- Other Random Toys, Experiments and Example Code
- P2P and File Sharing
- Programming
- Resource Embedding
- RPC
- Scanner and Parser Generators
- Security
- Simulation Modeling
- Sorting
- Source Code Management
- Storage
- Strings and Text
- Testing
- Unix
- Unsorted
- Validation
- Version Control
- Virtual Machines and Languages
- Web Applications
- Web Libraries
- Windows
Astronomy
- go-fits – FITS (Flexible Image Transport System) format image and data reader
- astrogo/fitsio – Pure Go FITS (Flexible Image Transport System) format image and data reader/writer
- cosmo – Cosmological distance and time calculations for common cosmologies (Friedmann-Lemaître-Robertson-Walker metric).
- gonova – A wrapper for libnova — Celestial Mechanics, Astrometry and Astrodynamics Library
- meeus – Implementation of “Astronomical Algorithms” by Jean Meeus
- novas – Interface to the Naval Observatory Vector Astrometry Software (NOVAS)
Build Tools
- colorgo – Colorize go build output
- dogo – Monitoring changes in the source file and automatically compile and run (restart)
- fileembed-go – This is a command-line utility to take a number of source files, and embed them into a Go package
- gb – A(nother) build tool for go, with an emphasis on multi-package projects
- gg – A tiny multi golang projects env/make management tool.
- GG – A build tool for Go in Go
- godag – A frontend to the Go compiler collection
- goenv – goenv provides Go version and Go workspace management tools
- gopei – Simple Go compiler and LiteIDE installer for Unix/Linux that adds many features like github support and presenter.
- go-pkg-config – lightweight clone of pkg-config
- goscons – Another set of SCons builders for Go
- go-server – Agile server framework.
- gotgo – An experimental preprocessor to implement \’generics\’
- gows – Go workspace manager
- goxc – A build tool with a focus on cross-compiling, packaging, versioning and distribution
- GVM – GVM provides an interface to manage Go versions
- Realize – A Go build system with file watchers, output streams and live reload. Run, build and watch file changes with custom paths.
- SCons Go Tools – A collection of builders that makes it easy to compile Go projects in SCons
- Task – A task runner / simple alternative to Make
Caching
- cache – LevelDB style LRU cache for Go, support non GC object cache.
- cache2go – Concurrency-safe caching library with expiration capabilities and access counters
- go-cache – An in-memory key:value store/cache (similar to Memcached) library for Go, suitable for single-machine applications
- golibs/cache – A tiny cache package
- gomemcached – A memcached server in go
- gomemcache – a memcached client
- go-slab – Slab allocator for go.
- groupcache – Caching and cache-filling library, intended as a replacement for memcached in many cases
- libmemcache – Fast client and server libraries speaking memcache protocol
- memcached-bench – Benchmark tool for memcache servers
- memcached – Fast memcache server, which supports persistence and cache sizes exceeding available RAM
- memcache – go memcached client, forked from YouTube Vitess
- rend – A memcached proxy that manages data chunking and L1/L2 caches
- YBC bindings – Bindings for YBC library providing API for fast in-process blob cache
Cloud Computing
- LXD Daemon based on liblxc offering a REST API to manage containers
- Docker – The Linux container runtime. Developed by dotCloud.
- Enduro/X ASG Application Server for Go. Provides application server and middleware facilities for distributed transaction processing. Supports microservices based application architecture. Developed by ATR Baltic.
- Kubernetes – Container Cluster Manager from Google.
- flamingo – A Lightweight Cloud Instance Contextualizer.
- gocircuit – A distributed operating system that sits on top of the traditional OS on multiple machines in a datacenter deployment. It provides a clean and uniform abstraction for treating an entire hardware cluster as a single, monolithic compute resource. Developed by Tumblr.
- gosync – A package for syncing data to and from S3.
- juju – Orchestration tool (deployment, configuration and lifecycle management), developed by Canonical.
- mgmt – Next Generation Configuration Management tool (parallel, event driven, distributed system) developed by @purpleidea, (a Red Hat employee) and the mgmt community.
- rclone – “rsync for cloud storage” – Google Drive, Amazon Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Cloudfiles, Google Cloud Storage, Yandex Files
- ShipBuilder – ShipBuilder is a minimalist open source platform as a service, developed by Jay Taylor.
- swift – Go language interface to Swift / Openstack Object Storage / Rackspace cloud files
- Tsuru – Tsuru is an open source polyglot cloud computing platform as a service (PaaS), developed by Globo.com.
- aws-sdk-go – AWS SDK for the Go programming language.
Command-line Option Parsers
- argcfg – Use reflection to populate fields in a struct from command line arguments
- autoflags – Populate go command line app flags from config struct
- cobra – A commander for modern go CLI interactions supporting commands & POSIX/GNU flags
- command – Add subcommands to your CLI, provides help and usage guide.
- docopt.go – An implementation of docopt in the Go programming language.
- getopt – full featured traditional (BSD/POSIX getopt) option parsing in Go style
- getopt – Yet Another getopt Library for Go. This one is like Python\’s.
- gnuflag – GNU-compatible flag parsing; substantially compatible with flag.
- go-commander – Simplify the creation of command line interfaces for Go, with commands and sub-commands, with argument checks and contextual usage help. Forked from the “go” tool code.
- go-flags – command line option parser for go
- goopt – a getopt clone to parse command-line flags
- go-options – A command line parsing library for Go
- options – Self documenting CLI options parser
- opts.go – lightweight POSIX- and GNU- style option parsing
- pflag – Drop-in replacement for Go\’s flag package, implementing POSIX/GNU-style –flags.
- subcommands – A concurrent, unit tested, subcommand library
- uggo – Yet another option parser offering gnu-like option parsing. This one wraps (embeds) flagset. It also offers rudimentary pipe-detection (commands like ls behave differently when being piped to).
- writ – A flexible option parser with thorough test coverage. It\’s meant to “just work” and stay out of the way.
- cli – A Go library for implementing command-line interfaces.
- cmdline – A simple parser with support for short and long options, default values, arguments and subcommands.
- go-getoptions – Go option parser inspired on the flexibility of Perl’s GetOpt::Long.
Command-line Tools
- awless – A Mighty command-line interface for Amazon Web Services (AWS).
- boilr – A blazing fast CLI tool for creating projects from boilerplate templates.
- coshell – A drop-in replacement for GNU \’parallel\’.
- DevTodo2 – A small command-line per-project task list manager.
- dsio – Command line tool for Google Cloud Datastore.
- enumeration – Easy enumeration code generation.
- fzf – A command-line fuzzy finder
- gich – A cross platform which utility written in Go
- git-time-metric – Simple, seamless, lightweight time tracking for Git
- gister – Manage your github gists from the command-line
- gmail2go – Simple gmail multiple accounts cli mail checker
- gocreate – Command line utility that create files from templates.
- godocdoc – Start godoc and open it in your browser to the project in the current directory.
- gojson – Command-line tool for manipulating JSON for use in developing Go code.
- gopass – Command line password manager with git syncing capabilities
- GoPasswordCreator – A small tool, which creates random passwords
- GoNote – Command line SimpleNote client.
- Grozilla – File downloader utility with resume capability.
- jsonpp – A fast command line JSON pretty printer.
-
lsp – A human-friendlier alternative to
ls
- ltst – View the latest news of your choosing right in your terminal
- passhash – Command-line utility to create secure password hashes
- passman – A command-line password manager
- pdfcpu – PDF processor.
- pjs – Pretty print and search through JSON data structures fast.
- project – Very simple CLI tool to setup new projects from boilerplate templates.
- pwdgen – A small tool, which generate human password, written in Go.
- redis-view – A tree like tool help you explore data structures in your redis server
- remote-torrent – A simple tool for downloading Torrent remotely and retrieving files back over HTTP at full speed without ISP Torrent limitation
- restic – A fast, efficient and secure backup program
-
runtemplate – A very simple command-line tool for executing Go templates, useful for use with
go generate
. - runtemplate – A simple tool for executing Go templates to support generating Go code for your types.
-
sift – A fast and powerful open source alternative to
grep
- tecla – Command-line editing library
- wlog – A simple logging interface that supports cross-platform color and concurrency.
- wmenu – An easy to use menu structure for cli applications that prompts users to make choices.
- comb-go – A CLI tool implemented by Golang to manage CloudComb resources.
- JayDiff – A JSON diff utility written in Go.
Compression
- brotli – go bindings for Brotli algorithm.
- compress – Faster drop in replacements for gzip, zip, zlib, deflate
- dgolzo – LZO bindings
-
dictzip – A reader and writer for files in the random access
dictzip
format - fast-archiver – Alternative archiving tool with fast performance for huge numbers of small files
- gbacomp – A Go library to (de)compress data compatible with GBA BIOS
- go-lz4 – Port of LZ4 lossless compression algorithm to Go.
- go-lzss – Implementation of LZSS compression algorithm in Go
- go-sevenzip – Package sevenzip implements access to 7-zip archives (wraps C interface of LZMA SDK)
- go-zip – A wrapper around C library libzip, providing ability to modify existing ZIP archives.
- lzma – compress/lzma package for Go
- pgzip – Multicore gzip, compatible with the standard library
- snappy-go – Google\’s Snappy compression algorithm in Go
- yenc – yenc decoder package
- zappy – Package zappy implements the zappy block-based compression format. It aims for a combination of good speed and reasonable compression.
- ppmd-go – Golang bindings for the LZMA SDK library. (Only binded PPMD)
Concurrency and Goroutines
- grpool – Lightweight Goroutine pool.
- pool – Go consumer goroutine pool for easy goroutine handling + time saving.
- tunny – A goroutine pool.
- worker – An easy and lightweight concurrent job framework.
Configuration File Parsers
- awsenv – a small binary that loads Amazon (AWS) environment variables for a profile
- confl – nginx config syntax, lenient, encode/decode, custom marshaling
- configor – Golang Configuration tool that support YAML, JSON, TOML, Shell Environment
- flagfile – Adds parsing and serialization support to the standard library flag package (adds a –flagfile option)
- gcfg – read INI-style configuration files into Go structs; supports user-defined types and subsections
- globalconf – Effortlessly persist to and read flag values from an ini config file
- goconf – a configuration file parser
- goconfig – Configuration based on struct introspection, supports environment vars, command line args, and more.
- hjson – Human JSON, a configuration file format for humans. Relaxed syntax, fewer mistakes, more comments.
- jsonconfig – a JSON configuration file parser with comments support
- properties – Library for reading and writing properties files
- scribeconf – Facebook Scribe server configuration file parser
-
toml:
- go-toml-config – TOML-based config for Go
- go-toml – Go library for the TOML language
- gp-config – Subset of TOML syntax with basic and reflection APIs
- toml-go – An easy-to-use Go parser for the Toml format
- toml – TOML parser for Go with reflection
- tom-toml – TOML parser for Go, support comments/formatter/apply.
- uConfig – an unopinionated, extendable and plugable configuration management. Supports YAML, TOML, JSON, Env vars, K8s DAPI, et al.
- viper – a complete configuration solution supporting YAML, TOML & JSON and integration with command line flags
- yaml:
Console User Interface
- ansi – Easily create ansi escape code strings and closures to format, color console output
- ansiterm – pkg to drive text-only consoles that respond to ANSI escape sequences
- cons – A simple package for building interactive console tools.
- gnureadline – GNU Readline bindings
- go-ansiout – Another ANSI escape code sequence tool for use with command-line applications.
- gockel – a Twitter client for text terminals
- gocui – Minimalist library aimed at creating Console User Interfaces
- gocurse – Go bindings for NCurses
- gocurses – NCurses wrapper
- go-ibgetkey – “hot key” type user input package for use in processing keystrokes in command-line applications.
- go.linenoise – Linenoise bindings (simple and easy readline with prompt, optional history, optional tab completion)
- goncurses – An ncurses library, including the form, menu and panel extensions
- gopass – Allows typing of passwords without echoing to screen
- go-pullbarz – Fancy “light bar” menus like in Lotus 123 from the DOS days. Dependent on go-ibgetkey and go-ansiout.
- go.sgr – Terminal/console colors and text decoration (bold,underlined,etc).
- go-stfl – a thin wrapper around STFL, an ncurses-based widget toolkit
- goterminal – A go library that lets you write and then re-write the text on terminal, to update progress. It works on Windows too!
- go-web-shell – Remote web shell, implements a net/http server.
- igo – A simple interactive Go interpreter built on exp/eval with some readline refinements
- oh – A Unix shell written in Go
- pty – obtain pseudo-terminal devices
- readline – A pure go implementation for GNU-Readline kind library
- termbox-go – A minimalist alternative to ncurses to build terminal-based user interfaces
- termios – Terminal support
- termon – Easy terminal-control-interface for Go.
- uilive – uilive is a go library for updating terminal output in realtime.
- uiprogress – A library to render progress bars in terminal applications.
- uitable – A library to improve readability in terminal apps using tabular data.
- yandex-weather-cli – Command line interface for Yandex weather service
Continuous Integration
- goveralls – Go integration for Coveralls.io continuous code coverage tracking system.
- overalls – Multi-Package go project coverprofile for tools like goveralls
Cryptography
- BLAKE2b – Go implementation of BLAKE2b hash function
- cryptogo – some useful cryptography-related functions, including paddings (PKCS7, X.923), PBE with random salt and IV
- cryptoPadding – Block padding schemes implemented in Go
- dkeyczar – Go port of Google\’e Keyczar cryptography library
- dkrcrypt – Korean block ciphers: SEED and HIGHT
- dskipjack – Go implementation of the SKIPJACK encryption algorithm
- go-cs – concurrent ssh client.
- go-ed25519 – CGO bindings for Floodberry\’s ed25519-donna. Fast batch verification.
- go-hc128 – Go implementation of HC-128, an eSTREAM stream cipher
- go-jose – Go implementation of the JOSE standards
- go-minilock – Go implementation of the minilock file encryption system.
- GoSkein – Implementation of Skein hash and Threefisch crypto for Go
- keccak – A keccak (SHA-3) implementation
- ketama.go – libketama-style consistent hashing
- kindi – encryption command line tool
- openssl – openssl bindings for go
- otrcat – a general purpose command-line tool for communicating using the Off-The-Record protocol
- scrypt – Go implementation of Colin Percival\’s scrypt key derivation function
- simpleaes – AES encryption made easy
- siphash – SipHash: a fast short-input pseudorandom function
- SRP – SRP: Secure Remote Password – Implementation in go
- ssh.go – SSH2 Client library
- ssh-vault – encrypt/decrypt using ssh keys
- themis – Multi-platform high-level cryptographic library for protecting sensitive data: secure messaging with forward secrecy, secure data storage (AES256GCM); suits for building end-to-end encrypted applications
- tiger – Tiger cryptographic hashing algorithm
- whirlpool – whirlpool cryptographic hashing algorithm
- go-lioness – Lioness wide-block cipher using Chacha20 and Blake2b
- go-sphinxmixcrypto – Sphinx mix network cryptographic packet format operations
Data Processing
- automi – Compose process and integration flows on Go channels
- gostatsd – Statsd server and library.
- Heka – Real time data and log file processing engine.
- Kapacitor – Framework for processing, monitoring and alerting on timeseries data.
- pipe – Several functional programming supporting in golang (Map/Reduce/Filter)
- proto – Map/Reduce/Filter etc. for Go using channels as result streams.
- regommend – Recommendation engine.
- rrd – Bindings for rrdtool.
- XConv – Convert any value between types (base type, struct, array, slice, map, etc.)
- ratchet – A library for performing data pipeline / ETL tasks in Go.
- Glow – Glow is an easy-to-use distributed computation system, similar to Hadoop Map Reduce, Spark, Flink, Storm.
- Gleam – Fast, efficient, and scalable distributed map/reduce system, DAG execution, in memory or on disk, runs standalone or distributedly.
Data Structures
Collections
- collections – Several common data structures
- data-structures – A collection of data-structures (ArrayList, SortedList, Set, AVL Tree, Immutable AVL Tree, B+Tree, Ternary Search Trie, Hash Table (Separate Chaining), Linear Hash Table)
- ps – Persistent data structures
- Tideland golib – A collections library
Hashtables
- gohash – A simple linked-list hashtable that implements sets and maps
- go-maps – Go maps generalized to interfaces
Lists
- fs2/mmlist – A memory mapped list.
- GoArrayList – GoArrayList is a Go language substitute for the Java class ArrayList, with very nearly all features.
- goskiplist – A skip list implementation in Go.
- itreap – An immutable ordered list, internally a treap.
- ListDict – Python List and Dict for Go
- skip – A fast position-addressable ordered map and multimap.
- Skiplist – A fast indexable ordered multimap.
- skiplist – A skip list implementation. Highly customizable and easy to use.
- skiplist – Skiplist data structure ported from Redis\’s Sorted Sets.
- stackgo – A fast slice-based stack implementation.
Queues
- fifo_queue – Simple FIFO queue
- figo – A simple fifo queue with an optional thread-safe version.
- go.fifo – Simple auto-resizing thread-safe fifo queue.
- gopqueue – Priority queue at top of container/heap
- go-priority-queue – An easy to use heap implementation with a conventional priority queue interface.
- golibs/stack – A LIFO and ringbuffer package
- gringo – A minimalist queue implemented using a stripped-down lock-free ringbuffer
-
heap – A general heap package without converting elements to
interface{}
and back. - queued – A simple network queue daemon
- queue – A queue manager on top of Redis
Graphs
- graph – Library of basic graph algorithms
- graphs – Implementation of various tree, graph and network algorithms
Sets
- disjoint – Disjoint sets (union-find algorithm with path compression)
- golang-set – A full thread-safe and unsafe set implementation for Go.
- goset – A simple, thread safe Set implementation
- set – Set data structure for Go
Trees
- b – Package b implements B+trees with delayed page split/concat and O(1) enumeration. Easy production of source code for B+trees specialized for user defined key and value types is supported by a simple text replace.
- btree – Package btree implements persistent B-trees with fixed size keys, http://en.wikipedia.org/wiki/Btree
- btree – In-memory (not persistent) B-tree implementation, similar API to GoLLRB
- go-avltree – AVL tree (Adel\’son-Vel\’skii & Landis) with indexing added
- go-btree – Simple balance tree implementation
- go-darts – Double-ARray Trie System for Go
- GoLLRB – A Left-Leaning Red-Black (LLRB) implementation of 2-3 balanced binary search trees in Google Go
- go-merkle – Merkle-ized binary (search) trees with proofs.
- go-stree – A segment tree implementation for range queries on intervals
- go-radix, go-radix-immutable – Radix tree implementations.
- gtreap – Persistent treap implementation.
- rbtree – Yet another red-black tree implementation, with a C++ STL-like API
- rbtree – A high performance red-black tree with an API similar to C++ STL\’s for set, map, multiset, multimap.
- rtreego – an R-Tree library
- triego – Simple trie implementation for storing words
- prefixmap – Simple trie-based prefix-map for string-based keys
Other
- aurora – Cross-platform Beanstalk queue server console.
- bigendian – binary parsing and printing
- deepcopy – Make deep copies of data structures
- dgobloom – A Bloom Filter implementation
- epochdate – Compact dates stored as days since the Unix epoch
- etree – Parse and generate XML easily
- excelize – Golang library for reading and writing Microsoft Excel™ (XLSX) files.
- fsm – Minimalistic state machine for use instead of booleans
- go-algs/ed – Generalized edit-distance implementation
- go-algs/maxflow – An energy minimization tool using max-flow algorithm.
- go-extractor – Go wrapper for GNU libextractor
- gocrud – Framework for working with arbitrary depth data structures.
- Gokogiri – A lightweight libxml wrapper library
- GoNetCDF – A wrapper for the NetCDF file format library
- goop – Dynamic object-oriented programming support for Go
- gopart– Type-agnostic partitioning for anything that can be indexed in Go.
- gotoc – A protocol buffer compiler written in Go
- govalid – Data validation library
- goxml – A thin wrapper around libxml2
- hyperloglog – An implementation of the HyperLogLog and HyperLogLog++ algorithms for estimating cardinality of sets using constant memory.
- itertools – Provides generic iterable generator function along with functionality similar to the itertools python package.
- jsonv – A JSON validator
- libgob – A low level library for generating gobs from other languages
- ofxgo – A library for querying OFX servers and/or parsing the responses (and example command-line client).
- Picugen – A general-purpose hash/checksum digest generator.
- tribool – Ternary (tree-valued) logic for Go
- Tuple – Tuple is a go type that will hold mixed types / values
- vcard – Reading and writing vcard file in go. Implementation of RFC 2425 (A MIME Content-Type for Directory Information) and RFC 2426 (vCard MIME Directory Profile).
-
mxj – Marshal/Unmarshal XML doc from/to
map[string]interface{}
or JSON - xlsx – A library to help with extracting data from Microsoft Office Excel XLSX files.
- goxlsxwriter – Golang bindings for libxlsxwriter for writing XLSX (Excel) files
- simple-sstable – A simple, no-frills SSTable format and implementation in Go.
Databases
See also SQLDrivers page.
CockroachDB
- cockroachdb – A Scalable, Survivable, Strongly-Consistent SQL Database
Hazelcast IMDG
- Hazelcast IMDG Go Client – The official Go client implementation for Hazelcast IMDG, the open source in-memory data grid.
MongoDB
- mgo – Rich MongoDB driver for Go
- rocks-stata – MongoDB Backup Utility
MySQL
- Go-MySQL-Driver – A lightweight and fast MySQL-Driver for Go\’s database/sql package
- MyMySQL – MySQL Client API written entirely in Go.
- TiDB – MySQL compatible distributed database modeled after Google\’s F1 design.
- vitess – Scaling MySQL databases for the web
- mysqlsuperdump – Generate partial and filtered dumps of MySQL databases
ODBC
PostgreSQL
- go-libpq – cgo-based Postgres driver for Go\’s database/sql package
- go-pgsql – A PostgreSQL client library for Go
- pgsql.go – PostgreSQL high-level client library wrapper
- pgx – Go PostgreSQL driver that is compatible with database/sql and has native interface for more performance and features
- pq – Pure Go PostgreSQL driver for database/sql
- yoke – Postgres high-availability cluster with auto-failover and automated cluster recovery
- kallax – PostgreSQL typesafe ORM
QL
- ql – A pure Go embedded (S)QL database.
Redis
- godis – Simple client for Redis
- Go-Redis – Client and Connectors for Redis key-value store
- go-redis – Redis client built on the skeleton of gomemcache
- Redigo – Go client for Redis.
- redis – Redis client for Go
RethinkDB
- GoRethink – RethinkDB Driver for Go
SQLite
- gosqlite3 – Go Interface for SQLite3
- gosqlite (forked) – A fork of gosqlite
- gosqlite – a trivial SQLite binding for Go.
- go-sqlite – A database/sql driver and standalone sqlite3 interface
- mattn\’s go-sqlite3 – sqlite3 driver conforming to the built-in database/sql interface
ORM
- beedb – beedb is an ORM for Go. It lets you map Go structs to tables in a database
- FilterXorm – Build conditions for xorm project.
- go-modeldb – A simple wrapper around sql.DB for struct support.
- gorm – An ORM library for Go, aims for developer friendly
- gorp – SQL mapper for Go
- go-store – Data-store library for Go that provides a set of platform-independent interfaces to persist and retrieve key-value data.
- hood – Database agnostic ORM for Go. Supports Postgres and MySQL.
- lore – Simple and lightweight pseudo-ORM/pseudo-struct-mapping environment for Go.
- qbs – Query By Struct. Supports MySQL, PostgreSQL and SQLite3.
- sqlboiler – Database-first ORM via code generation.
- sqlgen – Go code generation for SQL interaction.
- structable – Struct-to-table database mapper.
- xorm – Simple and Powerful ORM for Go.
- reform – A better ORM for Go, based on non-empty interfaces and code generation.
- go-queryset – 100% type-safe ORM for Go with code generation and MySQL, PostgreSQL, Sqlite3, SQL Server support.
Key-Value-Stores
- bolt – Persistent key/value store inspired by LMDB.
- dbm – Package dbm (WIP) implements a simple database engine, a hybrid of a hierarchical and/or a key-value one.
- fs2/bptree – A memory mapped B+Tree with duplicate key support. Appropriate for large amounts of data (aka +100 GB). Supports both anonymous and file backed memory maps.
- Diskv – Home-grown, disk-backed key-value store
- etcd – Highly-available key value store for shared configuration and service discovery
- gkvlite – Pure go, simple, ordered, atomic key-value persistence based on append-only file format.
- gocask – Key-value store inspired by Riak Bitcask. Can be used as pure go implementation of dbm and other kv-stores.
- goleveldb – Another implementation of LevelDB key/value in pure Go.
- kv – Yet another key/value persistent store. Atomic operations, two phase commit, automatic crash recovery, …
- leveldb-go – This is an implementation of the LevelDB key/value database.
- levigo – levigo provides the ability to create and access LevelDB databases.
- persival – Programatic, persistent, pseudo key-value storage
Graph Databases
- cayley – 100% Go graph database, inspired by Freebase and the Google Knowledge Graph.
- Dgraph – Fast, Distributed Graph DB with a GraphQL-like API.
- go-gremlin – A Go client for the Apache TinkerTop Graph analytics framework (Gremlin server).
NoSQL
- influxdb – Scalable datastore for metrics, events, and real-time analytics
- ledisdb – A high performance NoSQL like Redis.
- nodb – A pure Go embed Nosql database with kv, list, hash, zset, bitmap, set.
- tiedot – A NoSQL document database engine using JSON for documents and queries; it can be embedded into your program, or run a stand-alone server using HTTP for an API.
Other
- cabinet – Kyoto Cabinet bindings for go
- camlistore – Personal distributed storage system for life.
- cdb.go – Create and read cdb (“constant database”) files
- go-clickhouse – Connector to Yandex Clickhouse (column-oriented database)
- CodeSearch – Index and perform regex searches over large bodies of source code
- couch-go – newer maintained CouchDB database binding
- couchgo – The most feature complete CouchDB Adapter for Go. Modeled after couch.js.
- dbxml – A basic interface to Oracle Berkeley DB XML
- drive – A Google drive command line client
- Event Horizon – Toolkit for Command Query Responsibility Segregation and Event Sourcing (CQRS/ES)
- go-db-oracle – GO interface to Oracle DB
- gographite – statsd server in go (for feeding data to graphite)
- gokabinet – Go bindings for Kyoto Cabinet DBM implementation
- go-model – Robust & Easy to use struct mapper and utility methods for Go
- go-notify – GO bindings for the libnotify
- goprotodb – A binding to Berkeley DB storing records encoded as Protocol Buffers.
- go-rexster-client – Go client for the Rexster graph server (part of the TinkerPop suite of graph DB tools)
- goriak – Database driver for riak database (project homepage is now on bitbucket.org)
- goriakpbc – Riak driver using Riak\’s protobuf interface
- gotyrant – A Go wrapper for tokyo tyrant
- go-wikiparse – mediawiki dump parser for working with wikipedia data
- hdfs – go bindings for libhdfs
- JGDB – JGDB stands for Json Git Database
- mig – Simple SQL-based database migrations
- mongofixtures – A Go quick and dirty utility for cleaning MongoDB collections and loading fixtures into them.
- Neo4j-GO – Neo4j REST Client in Go
- neoism – Neo4j graph database client, including Cypher and Transactions support.
- null – Package for handling null values in SQL
- Optimus Cache Prime – Smart cache preloader for websites with XML sitemaps.
- piladb – Lightweight RESTful database engine based on stack data structures.
- pravasan – Simple Migration Tool (like rake db:migrate with more flexibility)
- riako – High level utility methods for interacting with Riak databases
- sqlbuilder – SQL query builder with row mapping
- sqlf – Create parameterized SQL statements in Go, sprintf style
- squirrel – Fluent SQL generation for Go
- Sublevel – Separate sections of the same LevelDB
- Weed File System – fast distributed key-file store
- whisper-go – library for working with whisper databases
- remapper – library to convert/map data from one type to another
- xo – CLI to generate idiomatic Go code for databases
- go-batcher – Simply create and use batch handler in Go
Date
- now – Now is a time toolkit for golang.
- date – A package for working with dates.
- date – For dates, date ranges, time spans, periods, and time-of-day.
- gostrftime – strftime(3) like formatting for time.Time
- goment – Go time library inspired by Moment.js
- tai64 – tai64 and tai64n parsing and formatting
-
tuesday – A Strftime implementation that\’s compatible with Ruby\’s
Time.strftime
- Tideland golib – Timex extensions
- hijri – A small helper library to convert a Hijri date to a Gregorian date according to Ummul Qura calendar.
Development Tools
- cwrap – Go wrapper (binding) generator for C libraries.
- demand – Download, build, cache and run a Go app easily.
- glib – Bindings for GLib type system
- go-callvis – Visualize call graph of your Go program using dot format.
- gocog – A code generator that can generate code using any language
- godepgraph – Create a dependency graph for a go package
- godev – Recompiles and runs your Go code on source change. Also watches all your imports for changes.
- godiff – diff file comparison tool with colour html output
- gonew – A tool to create new Go projects
- go-play – A HTML5 web interface for experimenting with Go code. Like http://golang.org/doc/play but runs on your computer
- gore – A Go REPL. Featured with line editing, code completion, and more
- gorun – Enables Go source files to be used as scripts.
- go-spew – Implements a deep pretty printer for Go data structures to aid in debugging
- goven – Easily copy code from another project into yours
- gowatcher – Reload a specified go program automatically by monitoring a directory.
- GoWatch – GoWatch watches your dev folder for modified files, and if a file changes it restarts the process.
- goweb – Literate programming tools for Go based on CWEB by Donald Knuth and Silvio Levy.
- hopwatch – simple debugger for Go
- hsandbox – Tool for quick experimentation with Go snippets
- Inject – Library for dependency injection in Golang (from Facebook)
- liccor – A tool for updating license headers in Go source files
- liteide – An go auto build tools and qt-based ide for Go
- Livedev – Livedev is a development proxy server that enables live code reloading.
- Martian – HTTP proxy designed for use in E2E testing.
- nvm-windows – Node.js version manager for Windows
- prettybenchcmp – Store and compare benchmarks history locally.
- rerun – Rerun watches your binary and all its dependencies so it can rebuild and relaunch when the source changes.
- syntaxhighlighter – language-independent code syntax highlighting library
- toggle – A feature toggle library with built in support for environment variable backed toggling. pluggable backing engine support.
- trace – A simple debug tracing
Emacs Tags
- egotags – ETags generator
- tago1 – etags generator for go that builds with go 1
- tago – Emacs TAGS generator for Go source
Distributed/Grid Computing
- celeriac – A library for adding support for interacting and monitoring Celery workers, tasks and events in Go
- donut – A library for building clustered services in Go
- libchan – Go-like channels over the network
- locker – A distributed lock service built on top of etcd.
- dlock – A native Go distributed lock manager (client and server) using gRPC.
- mangos – An implementation of the Scalable Protocols based on nanomsg
- redsync – Redis-based distributed mutual exclusion lock implementation
- Skynet – Skynet is distributed mesh of processes designed for highly scalable API type service provision.
- Tideland golib – Includes a map/reduce library
Documentation
- examplgen – Insert code from .go files to documents (examples to project\’s readme, for instance).
- godocdown – Format package documentation (godoc) as GitHub friendly Markdown
- GoDoc.org – GoDoc.org generates documentation on the fly from source on Bitbucket, Github, Google Project Hosting and Launchpad.
- golangdoc – Godoc for Golang, support translate.
- Mango – Automatically generate unix man pages from Go sources
- redoc – Commands documentation for Redis
- sphinxcontrib-golangdomain – Sphinx domain for Go
- test2doc – Generate documentation for your go units from your unit tests.
Editors
- A – A graphical text and binary editor based on Acme
- Conception – Conception is an experimental research project, meant to become a modern IDE/Language package. demo video
- de – A modal graphical editor with Acme and vi features
- Go-bbpackage – BBEdit package for Go development
- goclipse – An Eclipse-based IDE for Go.
- Go conTEXT – Highlighter plugin
- godev – Web-based IDE for the Go language
- godit – A microemacs-like text editor written in Go.
- gofinder – (code) search tool for acme
- go-gedit – Google Go language plugin for gedit
- golab – go local application builder – a web-based Go ide
- Google Go for Idea – Google Go language plugin for Intellij IDEA
- micro – A modern and intuitive terminal-based text editor.
- T – An Acme/Sam like text editor
- tabby – Source code editor
- ViGo – A vim-like text editor.
- Wide – A Web-based IDE for Teams using Golang.
- Hectane – Lightweight SMTP client including a built-in mail queue backed by on-disk storage.
- gmail – Simple library for sending emails from a Gmail account, for people not interested in dealing with protocol details.
- go-mail – Email utilities including RFC822 messages and Google Mail defaults.
- Gomail – A simple and efficient package to send emails.
- go-ses – Amazon AWS Simple Email Service (SES) API client
- Inbucket – Inbucket is an email testing service; it will accept messages for any email address and make them available to view via a web interface.
- mail.go – Parse email messages
- MailHog – Email testing service, inspired by MailCatcher.
- MailSlurper – A handy SMTP mail server useful for local and team application development. Slurp mail into oblivion!
- chasquid – SMTP server written in Go.
Error handling
- hierr – Nesting errors in hierarchy.
- errgo – Error tracing and annotation.
- errors – The juju/errors package provides an easy way to annotate errors without losing the original error context, and get a stack trace back out of the error for the locations that were recorded.
- errors – errors augments and error with a file and line number.
- goerr – Allows to make a separate(modular) and reusable error handlers. Exception-like panic() recover() mechanism using Return(error) and catching err := OR1(..)
- panicparse – Parse panics with style.
- Space Monkey errors – Go\’s missing errors library – stack capture, error hierarchies, error tags
- Tideland golib – Detailed error values
Encodings and Character Sets
- base58 – Human input-friendly base58 encoding
- bencode-go – Encoding and decoding the bencode format used by the BitTorrent peer-to-peer file sharing protocol
- bsonrpc – BSON codec for net/rpc
- chardet – Charset detection library ported from ICU
- charmap – Character encodings in Go
- codec-msgpack-binc High Performance and Feature-Rich Idiomatic Go Library providing encode/decode support for multiple binary serialization formats: msgpack
- colfer – high-performance binary codec
- gobson – BSON (de)serializer
- go-charset – Conversion between character sets. Native Go.
- go.enmime – MIME email parser library for Go (native)
- go-msgpack – Comprehensive MsgPack library for Go, with pack/unpack and net/rpc codec support (DEPRECATED in favor of codec )
- gopack – Bit-packing for Go
- go-simplejson – a Go package to interact with arbitrary JSON
- go-wire – Binary and JSON codec for structures and more
- go-xdr – Pure Go implementation of the data representation portion of the External Data Representation (XDR) standard protocol as specified in RFC 4506 (obsoletes RFC 1832 and RFC 1014).
- iconv-go – iconv wrapper with Reader and Writer
- magicmime — Mime-type detection with Go bindings for libmagic
- Mahonia – Character-set conversion library in Go
- mimemagic – Detect mime-types automatically based on file contents with no external dependencies
- msgpack – Msgpack format implementation for Go
- msgpack-json – Command-line utilities to convert between msgpack and json
- nnz – String and Int primitives that serialize to JSON and SQL null
- storable – Write perl storable data
- TNetstring – tnetstrings (tagged Netstrings)
File Systems
- afero – A File Sytem abstraction system for Go
- go.fs – A virtual file system abstraction layer.
- poller – Package poller is a file-descriptor multiplexer. It allows concurent Read and Write operations from and to multiple file-descriptors.
- vfsgen – Generates a vfsdata.go file that statically implements the given virtual filesystem.
Games
- Bampf – Arcade style game based on the Vu 3D engine.
- bloxorz – Solver for bloxorz basic levels
- ChessBuddy – Play chess with Go, HTML5, WebSockets and random strangers!
- Fergulator – An NES emulator, using SDL and OpenGL
- FlappyBird – A simple flappy bird clone written in golang.
- godoku – Go Sudoku Solver – example of “share by communicating”
- Gongo – A program written in Go that plays Go
- gospeccy – A ZX Spectrum 48k Emulator
- Ludo Game – Ludo Board game powered by Go on Appengine
- pinkman – command line based chess interface to UCI compatible chess engines
- Pong – A simple Pong clone written in golang
- pong-command – Joke command,ping-like pong.
- Steven – A Minecraft client in Go
- ukodus – Sudoku solver in Go
- WolfenGo – A Wolfenstein3D clone in Go, using OpenGL 2.1
GIS
- geojson – Go package to quick and easy create json data in geojson format. description
- go-geom – Efficient Open Geo Consortium-style geometries with native Go GeoJSON and WKB encoding and decoding (work-in-progress)
- go.geo – Geometry/geography library targeted at online mapping
- go.geojson – Marshalling and Unmarshalling of GeoJSON objects
- gogeos – Go library for spatial data operations and geometric algorithms
- go-proj-4 – An interface to the Cartographic Projections Library PROJ.4
- go-kml – Google Earth KML generation
- go-polyline – Google Maps polyline encoding and decoding
- orb – 2d geometry manipulation (length, area, polygon contains, etc.) with geojson, wkb, mvt support
- osm – General purpose library for reading, writing and working with OpenStreetMap data
- UTM – Bidirectional UTM-WGS84 converter
Go Implementations
- llgo – LLVM-based Go compiler, written in Go
Graphics and Audio
- AnsiGo – Simple ANSi to PNG converter written in pure Go
- Arclight – Arclight is a tool for rendering images
- bild – A collection of image processing algorithms in pure Go
- bimg – Small Go library for fast image resize and transformation using libvips
- blend – Image processing library and rendering toolkit for Go.
- bpg – BPG decoder for Go.
- chart – Library to generate common chart (pie, bar, strip, scatter, histogram) in different output formats.
- draw2d – This package provide an API to draw 2d geometrical form on images. This library is largely inspired by postscript, cairo, HTML5 canvas.
- egl – egl bindings
- es2 – es2 bindings
- fourcc – Go implementation of FOURCC (four character code) (4CC) identifiers for a video codecs, compression formats, colors, and pixel format used in media files.
- freetype-go – a Go implementation of FreeType
- gltf – library for marshaling and unmarshaling glTF
- glfw 3 – Go bindings for GLFW 3 library
- glfw – bindings to the multi-platform library for opening a window, creating an OpenGL context and managing input
- glh – OpenGL helper functions to manage text, textures, framebuffers and more
- gl – OpenGL bindings using glew
- glu – bindings to the OpenGL Utility Library
- gmask – Go adaptation of the Cmask utility for Csound
- goalsa – Go bindings for ALSA capture and playback
- go-cairo – Go wrapper for the cairo graphics library
- gocl – Go OpenCL (gocl) binding, support OpenCL 1.1/1.2/2.0 on Mac/Linux/Windows/Android
- go-csnd6 – Go binding to the Csound6 API
- go-csperfthread – Go binding to the CsoundPerformanceThread helper class of the Csound6 API
- goexif – Retrieve EXIF metadata from image files
- goflac – Go bindings for decoding and encoding FLAC audio with libFLAC
- go-gd – Go bingings for GD
- GoGL – OpenGL binding generator
- go-gnuplot – go bindings for Gnuplot
- go-gtk3 – gtk3 bindings for go
- go-heatmap – A toolkit for making heatmaps
- GoHM – H.265/HEVC HM Video Codec in Go
- goHorde – Go Bindings for the Horde3d Rendering engine.
- GoMacDraw – A mac implementation of go.wde
- go-openal – Experimental OpenAL bindings for Go
- go-opencl – A go wrapper to the OpenCL heterogeneous parallel programming library
- go-opencv – Go bindings for OpenCV / 2.x API in gocv / 1.x API in opencv
- Go-OpenGL – Go bindings for OpenGL
- Goop – Audio synthesizer engine
- goray – Raytracer written in Go, based on Yafaray
- gosc – Pure Go OSC (Open Sound Control) library
- go-taglib – Go wrapper for TagLib, an audio meta-data parser
- go-tmx – A Go library that reads Tiled\’s TMX files
- GoVisa – H265/HEVC Bitstream Analyzer in Go
- go-vlc – Go bindings for libVLC
- go.wde – A windowing/drawing/event interface
- goxscr – Go rewrites of xscreensaver ports
- gst – Go bindings for GStreamer
- gumble – Client library for the Mumble VoIP protocol
- hgui – Gui toolkit based on http and gtk-webkit.
- imaginary – Simple and fast HTTP microservice for image resizing and manipulation
- imaging – Package imaging provides basic image manipulation functions (resize, rotate, flip, crop, etc.) as well as simplified image loading and saving.
- netpbm – Read and write Netpbm images from Go programs
- opencv – Go bindings for OpenCV
- osmesa – Go bindings for osmesa.
- Plotinum – An API for creating plots
- portaudio – A Go binding to PortAudio
- pulsego – Go binding for PulseAudio
- pulse-simple – Go bindings for PulseAudio\’s Simple API, for easy audio capture and playback.
- resize – Image resizing with different interpolations.
- RiGO – RenderMan Interface implementation in Go.
- smartcrop – Content aware image cropping
- starfish – A simple Go graphics and user input library, built on SDL
- stl – library for reading, writing, and manipulating Stereolithography (.stl) files used in 3D printing
- svgo – a library for creating and outputting SVG
- tag – a library for reading tag metadata and creating metadata-invariant checksums for audio files: FLAC, all IDv3 variants, and MP4 (ACC, ALAC)
- tga – TARGA image format encoding/decoding library
- tiff – Rich TIFF/BigTIFF/GeoTIFF decoder/encoder for Go.
- twilio-go – Go client for the Twilio API.
- videoinput – Go bindings for VideoInput (Windows).
- vu – Virtual Universe. A skeleton 3D engine.
- vulkan – Golang Bindings for Vulkan API.
- webp – WebP decoder and encoder for Go.
- wg – Web Graphics, display real time go graphics in browser, with user input.
- window – Optimized moving window for real-time data
- wingo – A fully-featured window manager written in Go.
- Winhello – An example Windows GUI hello world application
- wxGo – Go Wrapper for the wxWidgets GUI
- xgb – A fork of the x-go-binding featuring support for thread safety and all X extensions.
- xgbutil – A utility library to make use of the X Go Binding easier. (Implements EWMH and ICCCM specs, key binding support, etc.)
- x-go-binding – bindings for the X windowing system
GUIs and Widget Toolkits
- go-fltk – FLTK2 GUI toolkit bindings for Go
- go-gtk – Bindings for GTK
- go-qt5 – QT5 bindings for go
- gothic – Tcl/Tk Go bindings
- gotk3 – Go bindings for GTK3, requires GTK version 3.8
- go.uik – A UI kit for Go, in Go. (project is closed)
- go-webkit2 – Go bindings for the WebKitGTK+ v2 API (w/headless browser & JavaScript support)
- Gowut – Gowut (Go Web UI Toolkit) is a full-featured, easy to use, platform independent Web UI Toolkit written in pure Go, no platform dependent native code is linked or called.
- GXUI – A Go cross platform UI library.
- iup – Bindings for IUP
- mdtwm – Tiling window manager for X
- qml – QML support for the Go language
- ui – Platform-native GUI library for Go
- webview – Tiny cross-platform web UI library. Uses WebKit (Gtk/Cocoa) and MSHTML (Windows)
Hardware
- go.hid – Provides communication with USB Human Interface Devices.
- gortlsdr – A librtlsdr wrapper, which turns certain USB DVB-T dongles into a low-cost, general purpose software-defined radio receiver.
- hwio – Hardware I/O library for SoC boards including BeagleBone Black and Raspberry Pi.
- stressdisk – Stress test your disks / memory cards / USB sticks before trusting your valuable data to them
- gobot – Golang framework for robotics, drones, and the Internet of Things (IoT).
Language and Linguistics
- alpinocorpus-go – A reader and a writer for Alpino corpora.
- go-aspell – GNU Aspell spell checking library bindings for Go.
- go-language – A simple language detector using letter frequency data.
- go-ngram – An n-gram is a contiguous sequence of n items from a given sequence of text or speech.
- go-tokenizer – A Text Tokenizer library for Golang
- go.stringmetrics – String distance metrics implemented in Go
- goling – String Similarity(Cosine Similarity, Levenshtein Distance), Spell Check, Segmentation
- inflect – Word inflection library (similar to Ruby ActiveSupport::Inflector). Singularize(), Pluralize(), Underscore() etc.
- libtextcat – A Go wrapper for libtextcat.
- nlp – Go Natural Language Processing library supporting LSA (Latent Semantic Analysis).
- sego – Chinese language segmenter.
- snowball – Snowball stemmers for multiple languages
- textcat – N-gram based text categorization, with support for utf-8 and raw text
Logging and Monitoring
- colog – CoLog is a prefix-based leveled execution log for Go
- cue – Fast and flexible contextual logger. Supports output to file, syslog, structured syslog, stdout/stderr, socket, Loggly, Honeybadger, Opbeat, Rollbar, and Sentry.
- epazote – Automated Microservices Supervisor.
- factorlog – Really fast, featureful logging infrastructure (supports colors, verbosity, and many formats)
- vlog – Leveled log on std log for Go
- glog – Leveled execution logs for Go
- go-logging – Supports different logging backends like syslog, file and memory. Multiple backends can be utilized with different log levels per backend and logger.
- gomol – A multi-output logging library designed for outputs that support additional metadata with log messages.
- graylog-golang – graylog-golang is a full implementation for sending messages in GELF (Graylog Extended Log Format) from Google Go (Golang) to Graylog
- jWalterWeatherman – Seamless terminal printing and file logging that’s as easy to use as fmt.Println
- immortal – A *nix cross-platform (OS agnostic) supervisor
- log4go – Go logging package akin to log4j
- logger – Go logging with buffered output and multiple writers
- logrus – Structured, pluggable logging for Go with built-in hooks for third-party loggers: Airbrake, Papertrail, Loggly, Sentry…
- MailJet Live Event Dashboard – API monitoring in real time.
- monkit – A flexible process data collection, metrics, monitoring, instrumentation, and tracing library for Go
- Prometheus – Monitoring system and time-series database.
- rfw – Rotating file writer – a \’logrotate\’-aware file output for use with loggers
- sd – Writes to the systemd journal, supports user defined systemd journal fields
- seelog – Flexible dispatching, filtering, and formatting
- snap – Telemetry framework
- spacelog – Hierarchical, leveled, and structured logging library for Go
- statsgod – A rewrite of StatsD in Go.
- syslog – With this package you can create your own syslog server with your own handlers for different kind of syslog messages
- Tideland golib – Flexible logging
- timber – Configurable Logger for Go
- ul – Provides macOS Sierra/OSX Unified Loggging functionality via cgo
Machine Learning
- bayesian – A naive bayes classifier.
- ctw – Context Tree Weighting and Rissanen-Langdon Arithmetic Coding
- evo – a framework for implementing evolutionary algorithms in Go.
- go-algs/maxflow Maxflow (graph-cuts) energy minimization library.
- go-galib – Genetic algorithms.
- golinear – Linear SVM and logistic regression.
- go_ml – Linear Regression, Logistic Regression, Neural Networks, Collaborative Filtering, Gaussian Multivariate Distribution.
- gorgonia – Neural network primitives library (like Theano or Tensorflow but for Go)
- go-porterstemmer – An efficient native Go clean room implementation of the Porter Stemming algorithm.
- go-pr – Gaussian classifier.
- ntm – Neural Turing Machines implementation
- paicehusk – Go implementation of the Paice/Husk Stemmer
- go-mind – A neural network library built in Go
- Anna – Artificial Neural Network Aspiration, aims to be self-learning and self-improving software.
- Dialex – Dialex is a smart pipe that unscrambles text and makes it machine-readable.
Mathematics
- bayesian – Naive Bayesian Classification for Go
- blas – Go implementation of BLAS (Basic Linear Algebra Subprograms)
- cartconvert – cartography functions for the Go programming language
- clp – Go bindings for the COIN-OR Linear Programming (CLP) library
- Cvx – Convex optimization package, port of CVXOPT python package
- dice – Dice rolling library
- evaler – A simple floating point arithmetic expression evaluator
- fixed – A fixed point (Q32.32 format) math library
- geom – 2d geometry
- gini – SAT Solver/Boolean Logic Tools
- gochipmunk – Go bindings to the Chipmunk Physics library
- gocomplex – a complex number library
- godec – multi-precision decimal arithmetic
- gofd – concurrent finite domain constraint solver.
- go-fftw – Go bindings for FFTW – The Fastest Fourier Transform in the West
- go-fn – Special functions that would not fit in “math” pkg
- gographviz – Graphviz DOT language parser for Go
- go-gt – Graph theory algorithms
- go-humanize – Formatting numbers for humans.
- golibs/xmath – a collection of math functions (mostly mean algorithms)
- go-lm – Linear models in Go. Provides WLS and regression with t residuals via a cgo -> BLAS/LAPACK interface.
- go.mahalanobis – Naive implementation of the Mahalanobis distance using go.matrix
- gomat – lightweight FAST matrix and vector math
- go_matrix_cuda – GPU-Accelerated Linear Algebra Libraries based in CUDA
- go.matrix – a linear algebra package
- gonum – Scientific packages (linear algebra, BLAS, LAPACK, differentiation, plots, linear programming, statistics, …)
- go-symexpr – Symbolic math as an AST with derivatives, simplification, and non-linear regression
- gsl – GNU Scientific Library bindings
- interval – Package interval handles sets of ordered values laying between two, possibly infinite, bounds.
- mathutil – Package mathutil provides utilities supplementing the standard \’math\’ and \’rand\’ packages.
- mt19937_64 – Mersenne Twister int64 random source
- permutation – Package permutation generates permutations of the indices of a slice
- polyclip.go – Go implementation of algorithm for Boolean operations on 2D polygons
- primes – Simple functionality for working with prime numbers.
- prime – Go version of Segmented Sieve and non Segmented sieve to produce prime numbers
- primegen.go – Sieve of Atkin prime number generator
- pso-go – A library of PSO (Particle Swarm Optimization) for Go.
- rand – 64-bit version of the math/rand package with Mersenne twister support.
- roger – A Go client for the RServer, allowing you to invoke R programs from Go.
- sparse – Go Sparse matrix formats for linear algebra supporting scientific and machine learning applications, compatible with gonum matrix libraries.
- stats – A statistics package with common functions missing from the Golang standard library.
- statistics – GNU GSL Statistics (GPLv3)
- Tideland golib – Numerics package for statistcal analysis
- Units – Implements types, units, converter functions and some mathematics for some common physical types. lib
- vector – A small vector lib.
- humanize – formats large numbers into human readable small numbers
Microservices
- gokit – The Go Kit microservice framework (and author interview).
- go-micro – Go Micro is a microservices library which provides the fundamental building blocks for writing fault tolerant distributed systems at scale.
- kite – RPC server and client framework.
- car_registration – API wrapper for worldwide car registration data
Miscellaneous
- atexit – Simple atexit library
- bíogo – Basic bioinformatics functions for the Go language.
- Breaker – Breaker enables graceful degraded mode operations by means of wrapping unreliable interservice interface points with circuit breaker primitives.
- btcrpcclient – A Websocket-enabled Bitcoin JSON-RPC client.
- cast – Safe and easy casting from one type to another in Go
- CGRates – Rating system designed to be used in telecom carriers world
- cpu – A Go package that reports processor topology
- cron – A library for running jobs (funcs) on a cron-formatted schedule
- daemonigo – A simple library to daemonize Go applications.
- dbus-go – D-Bus Go library
- desktop – Open file/uri with default application (cross platform)
- devboard – Kanban board application based on Simple-Khanban
- dioder-api – An API to IKEA dioder LED-strips
- dump – An utility that dumps Go variables, similar to PHP\’s var_dump
- elPrep – A high-performance tool for preparing sequence alignment/map files in DNA sequencing pipelines
- env – Easily pull environment variables with defaults
- epub – Bindings for libepub to read epub content.
- EventBus – Lightweight event bus with async compatibility for Go .
- faker – Generate fake data, names, text, addresses, etc.
- fsnotify – File system notifications for Go
- functional – Functional programming library including a lazy list implementation and some of the most usual functions.
- GCSE – Go code search engine. source
- generate – runs go generate recursively on a specified path or environment variable and can filter by regex.
- go-amiando – Wrapper for the Amiando event management API
- go-bit – An efficient and comprehensive bitset implementation with utility bit functions.
- go-bitops – common bit operations for 32/64 bit integer
- go-business-creditcard – Validate/generate credit card checksums/names.
- gochem – A computational chemistry/biochemistry library.
- gocsv – Library for CSV parsing and emitting
- go.dbus – Native Go library for D-Bus
- go-ean – A minimal utility library for validating EAN-8 and EAN-13 and calculating checksums.
- go-eco – Functions for use in ecology
- go-erx – Extended error reporting library
- go-eventsocket – An event socket client/server library for the FreeSWITCH telephony platform.
- GoFakeIt – Fake Data Generator. 65+ different variations and examples for each
- go-fann – Go bindings for FANN, library for artificial neural networks
- GoFlow – Flow-based and dataflow programming library for Go
- goga – A genetic algorithm framework
- gogobject – GObject-introspection based bindings generator
- go-idn – a project to bring IDN support to Go, feature compatible with libidn
- GoLCS – Solve Longest Common Sequence problem in go
- golibs/as – Converting data types
- golife – Implementation of Game of Life for command line
- go-magic – A Go wrapper for libmagic
- go-magic – Simple interface to libmagic for Go Programming Language
- go-metrics – Go port of Coda Hale\’s Metrics library
- gommap – gommap enables Go programs to directly work with memory mapped files and devices in a very efficient way
- gomusicbrainz – MusicBrainz WS2 client library
- goneuro – Go driver for NeuroSky devices.
- goNI488 – A Go wrapper around National Instruments NI488.2 General Purpose Interface Bus (GPIB) driver.
- go-osx-plist – CoreFoundation Property List support for Go
- go-papi – Go interface to the PAPI performance API
- go.pcsclite – Go wrapper for pcsc-lite
- Go-PhysicsFS – Go bindings for the PhysicsFS archive-access abstraction library.
- go.pipeline – Library that emulates Unix pipelines
- go-pkg-mpd – A library to access the MPD music daemon
- go-pkg-xmlx – Extension to the standard Go XML package. Maintains a node tree that allows forward/backwards browser and exposes some simpel single/multi-node search functions
- goplan9 – libraries for interacting with Plan 9
- goPromise – Scheme-like delayed evaluation for Go
- go-qrand – Go client for quantum random bit generator service at random.irb.hr
- goraphing – A tool to generate a simple graph data structures from JSON data files
- go-selenium – Selenium WebDriver client for Go
- go-semvar – Semantic versions (see http:/semver.org)
- go-serial – Go binding to libserialport for serial port functionality (cgo).
- goST – A steam properties (steam table) library written for Go. This was designed as a native go equivalent to XSteam.
- go-taskstats – Go interface for Linux taskstats
-
gotenv – Loads environment variables from
.env
file - Gotgo – A Go preprocessor that provides an implementation of generics
- go-translate – Google Language Translate library
- go-uuid – Universal Unique IDentifier generator and parser
- gouuid – Pure Go UUID v3, 4 and 5 generator compatible with RFC4122
- go-villa – Some miscellaneous wrapper and small algorithms.(wrappers to slices, priority queues, path related apis, a string set type)
- Hranoprovod – Command-line calorie tracking
- lineup – A minimalistic message queue server
- mitigation – Package mitigation provides the possibility to prevent damage caused by bugs or exploits.
- nma.go – A NotifyMyAndroid client for go.
- notify – File system event notification library with API similar to os/signal.
- pargo – A library for parallel programming in Go.
- passwd – A parser for the /etc/passwd file
- pool – A generic worker pool
- procfile – A Procfile parser
- Prometheus Instrumentation/Metrics Client – This is a whitebox instrumentation framework for servers written in Go. It exposes programmatically-generated metrics automatically for use in the Prometheus time series collection and post-processing environment.
- randat – Devel tool for generating random bytestrings and encoding files in code-friendly forms
- recycler – A more flexible object recycling system than sync.Pool. Provides constructors and destructors for the objects as well as control over the length the free.
- replaykit – A library for replaying time series data.
- serial – Serial ports API (pure Go)
- sio – Package sio lets you access old serial junk. It\’s a go-gettable fork and modification of dustin\’s rs232 package.
- stats – Monitors Go MemStats + System stats such as Memory, Swap and CPU and sends via UDP anywhere you want for logging etc…
- symutils – Various tools and libraries to handle symbolic links
- toktok – Creates and resolves unique, typo & error-resilient, human-readable tokens
- twitterfetcher – A tool to make Twitter API requests using the Application-only authentication
- udis86 – Go bindings for libudis86
- ugo – underscore.js like toolbox for Go
- Vboxgo – user-like access to VirtualBox VMs from Go.
- Wukong – A highly extensible full-text search engine written in Go.
- xplor – Files tree browser for p9p acme
- yubigo – Yubikey OTP validation and auhtentication API client.
Music
- gmask – Go adaptation of the Cmask utility for Csound
- go-csnd6 – Go binding to the Csound6 API
- go-csperfthread – Go binding to the CsoundPerformanceThread helper class of the Csound6 API
- go-libshout – Go bindings for libshout
- gompd – A client interface for the MPD (Music Player Daemon)
- launchpad – A Go client for Novation Launchpad
- portmidi – Go bindings for libportmidi
Networking
DNS
- bitz – BitMessage client node and library
- dingo – A DNS client in Go that supports Google DNS over HTTPS
- dns – A DNS library in Go
- dnsimple – an interface to the DNSimple API
- dyndnscd – a configurable dyndns client
- GeoDNS – geo-aware authoritative DNS server
- grong – Small authoritative DNS name server
- mdns – Multicast DNS library for Go
- hostsfile – /etc/hostsfile reverse lookup IP => names
- dnss – DNS secure proxy, supports DNS over HTTPS and GRPC
- domainerator – Command line tool to combine wordlist and suffixes/TLDs into domain names and check if they are registered or not.
- dns – client and server implementations in Go
FTP
- ftp4go – An FTP client for Go, started as a port of the standard Python FTP client library
- ftp – Package ftp provides a minimal FTP client as defined in RFC 959
- ftps – An implementation of the FTPS protocol
- goftp – A FTP client library
HTTP
- apiproxy – proxy for HTTP/REST APIs with configurable cache timeouts
- boom – HTTP(s) benchmarking tool, Apache Benchmark replacement
- eventsource – Server-sent events for net/http server.
- fasthttp – Fast HTTP package for Go
- gbench – HTTP(s) Load Testing And Benchmarking Tool inspired by Apache Benchmark and Siege.
- gobench – HTTP/HTTPS load test and benchmark tool
- go-curl – libcurl bingding that supports go func callbacks
- goproxy – a programmable HTTP proxy.
- gostax – A Streaming API for XML (StAX) in go
- handlers – Collection of useful HTTP middlewares.
- HTTPLab – HTTPLabs let you inspect HTTP requests and forge responses.
- stress – Replacement of ApacheBench(ab), support for transactional requests, support for command line and package references to HTTP stress testing tool.
- sling – A Go HTTP client library for creating and sending API requests.
- httptail – tools push stdout/stderr to http chunked
IMAP
- go-imap – An IMAP library for clients and servers.
- go-imap – IMAP client library
- go-imap – Implementation of IMAP4rev1 client, as described in RFC 3501
Instant Messaging
- hanu – Framework for writing Slack bots
- gobir – Extensible IRC bot with channel administration, seen support, and go documentation querying
- goexmpp – XMPP client implementation
- goirc – event-based stateful IRC client framework
- go-irc – Simple IRC client library
- gorobot – a modular IRC bot
- go-xmpp – XMPP client library
- ircflu – IRC bot with support for commands, scripting and web-hooks
- irc.go – Go IRC bot framework
- sirius – [link is broken] A fast and ultra-lightweight chat server written in Go
- xmpp-client – an XMPP client with OTR (off-the-record) support
NNTP
- go-nntp – An NNTP client and server library for go
Protocol Buffers
- gogoprotobuf – another Go implementation of Protocol Buffers, but with extensions and code generation plugins.
- golang_protobuf_extensions – Protocol Buffer extensions to support streaming message encoding and decoding.
- goprotobuf – the Go implementation of Google\’s Protocol Buffers
- protorpc – Google Protocol Buffers RPC for Go and C++
rsync
- replican-sync – An rsync algorithm implementation in Go
- Rsync – Rsync algorithm as a Go library
Telnet
- telnet – Package telnet provides TELNET and TELNETS client and server implementations, for the Go programming language, in a style similar to the “net/http” library (that is part of the Go standard library) including support for “middleware”; TELNETS is secure TELNET, with the TELNET protocol over a secured TLS (or SSL) connection.
- telnet – A simple interface for interacting with Telnet connection
- telnets – A client for the TELNETS (secure TELNET) protocol.
VNC
- glibvnc – Go wrapper using CGO for the libvnc library.
Websockets
- Gorilla WebSocket – WebSocket protocol implementation
- websocketd – HTTP server that converts STDIN/STDOUT program into WebSockets service. Also handles HTML and CGI.
- wst – A dead simple WebSocket tester
- ws-cli – WebSocket command line client
ZeroMQ
- goczmq – Wrapper for the CZMQv3 interface – blog post
- gozmq – Go Bindings for 0mq (zeromq/zmq)
- zmq2 – A Go interface to ZeroMQ (zmq, 0MQ) version 2.
- zmq3 – A Go interface to ZeroMQ (zmq, 0MQ) version 3.
- zmq4 – A Go interface to ZeroMQ (zmq, 0MQ) version 4.
Misc Networking
- betwixt – Betwixt implements the OMA Lightweight M2M (LWM2M) protocol for Device Management and Monitoring
- canopus – CoAP Client/Server implementation (RFC 7252)
- chunkedreader – A light weight library for reading continuous fixed sized messages from TCP streams.
- circle – Go interface to the libcircle distributed-queue API
- createsend-go – API client for Monitor http://www.campaignmonitor.com (email campaign service)
- dmrgo – Library for with Hadoop Streaming map/reduce
- doozerconfig – Go package for managing json-encoded configuration in Doozer
- doozerd – A consistent distributed data store
- endless Zero downtime restarts for go servers (Drop in replacement for http.ListenAndServe/TLS)
- gearman-go – A native implementation for Gearman API with Go.
- Glue – Robust Go and Javascript Socket Library (Alternative to Socket.io)
- goagain – zero-downtime restarts in Go
- Go Ajax – Go Ajax is a JSON-RPC implementation designed to create AJAX powered websites.
- gobeanstalk – Go Beanstalkd client library
- go-camo – Go http image proxy (camo clone) to route images through SSL
- go-dbus – A library to connect to the D-bus messaging system
- go-diameter – Diameter stack and Base Protocol (RFC 6733)
- go-smpp – SMPP 3.4 protocol implementation
- go-flowrate – Data transfer rate control (monitoring and limiting)
- gogammu – Library for sending and receiving SMS
- go-icap – ICAP (Internet Content Adaptation Protocol) server library
- gonetbench – Simple TCP benchmarking tool
- gonetcheck – package for checking general internet access
- goodhosts – Simple hosts file (/etc/hosts) management in Go
- gopacket – Packet encoding/decoding, pcap/pfring/afpacket support, TCP assembly, and more!
- gopcap – A simple wrapper around libpcap
- goq – A persistent message queue written in Go.
- goradius – A Radius client written in Go
- go-rpcgen – ProtoBuf RPC binding generator for net/rpc and AppEngine
- gorpc – RPC optimized for high load
- GoRTP – RTP / RTCP stack implementation for Go
- GoSIPs – SIP (Session Initiation Protocol) Stack in Go
- mqtt – MQTT stack in Go
- gosndfile – Go binding for libsndfile
- gosnmp – an SNMP library written in GoLang.
- go-socket.io – A Socket.IO backend implementation written in Go
- gosocks – A SOCKS (SOCKS4, SOCKS4A and SOCKS5) proxy client library in Go.
- go-sslterminator – SSL terminator proxy
- go-statsd-client – Go statsd client library
- Gollum – A n:m multiplexer that gathers messages from different sources and broadcasts them to a set of destinations.
- Grumble – Mumble (VoIP) server implementation
- handlersocket-go – Go native library to connect to HandlerSocket interface of InnoDB tables
- HomeControl – an implementation of Apple\’s HomeKit Accessory Protocol (HAP)
- Hprose – Hprose is a High Performance Remote Object Service Engine.
- httpfstream – streaming append and follow of HTTP resources (using WebSockets)
- ipaddress – Convenient ip address functions: ip -> int, int -> ip, and IPNet broadcast address
- iris-go – Go binding for the Iris decentralized messaging framework.
- iris – Peer-to-peer messaging for back-end decentralization.
- kafka.go – Producer & Consumer for the Kafka messaging system
- lcvpn – Decentralized VPN implementation
- ldap – Basic LDAP v3 functionality for the GO programming language.
- mbxchan – An easy communication between distributed Go applications using standard Go channels and remote procedure calls.
- nagiosplugin – package for writing Nagios/monitoring plugins
- NATS – NATS distributed messaging system client for Go
- netsnail – A low-bandwidth simulator
- netutils – Simple interface for turning TCP Sockets into channels.
- npipe – a pure Go wrapper for Windows named pipes
- norm – reliable UDP using multicast and unicast sockets
- opendap – Go wrapper for Openldap
- pusher-http-go – Go library for interacting with the Pusher Realtime API
- QRP – QRP is a simple packet-based RPC protocol designed as a simple alternative to Go\’s rpc, that can run over UDP
- remotize – A remotize package and command that helps remotizing methods without having to chaneg their signatures for rpc
- Resgate – A Realtime + REST API Gateway for NATS to create web APIs with live data
- rs232 – Serial interface for those of us who still have modems (or arduinos)
- rss – RSS parsing library.
- seamless – Reverse TCP Proxy with HTTP management API
- shell2http – Executing shell commands via simple http server
- sockjs-go – Implements server side counterpart for the SockJS-client browser library.
- SOCKS5 Server – Scalable SOCKS5 server with Access Control Lists
- spark – Emergency web server (for static files)
- spdy – SPDY library, wired into net/http, currently supporting servers only.
- statsd-go – Statsd implementation in Go, forked from gographite, which submits to Ganglia
- stompngo_examples – Examples for stompngo.
- stompngo – A Stomp 1.1 Compliant Client
- tcp_fallback – A TCP proxy implementing a simple fallback mechanism.
- tcpmeter – A TCP throughput measuring tool
- toxiproxy – Framework for simulating network conditions.
- traceroute – A traceroute implementation
- traefik – Modern, reverse proxy in Go
- Uniqush – A free and open source software which provides a unified push service for server-side notification to apps on mobile devices.
- uritemplates – A level 4 implementation of URI Templates (RFC 6570)
- VDED – Vector Delta Engine Daemon – track deltas in ever-increasing values (written in Go)
- zero-downtime-daemon – Configurable zero downtime daemon (Hot Update) framework for any kind of TCP,HTTP,FCGI services
- zeroupgrade – Upgrades network servers with zero downtime
- cwmp-proxy – Reverse cwmp proxy
- netstat-nat – Display NAT entries on Linux systems
- go-nat-pmp – A client for the NAT-PMP protocol used in Apple and open-source routers
- humanize-bytes – Command-line utilities to convert “MiB” etc to raw numbers, and back
Operating System Interfaces
- Go FUSE file system library – From-scratch implementation of the kernel-userspace communication protocol based on Russ Cox\’.
- Go-fuse – Library to write FUSE filesystems in Go
- go-osx-xattr – Package xattr wraps OS X functions to manipulate the extended attributes of a file, directory and symbolic link.
- inspect/os – Metrics library for operating system measurements (Linux/MacOSX)
- service – Service will install / un-install, start / stop, and run a program as a service (daemon) on Windows/Linux and OSX.
- go-nbd – Library to write block devices for Linux in Go.
Other Random Toys, Experiments and Example Code
- goconc – A collection of useful concurrency idioms and functions for Go, compiled
- go-crazy – An experimental source-to-source compiler for go
- go-gtk-demo – A demonstration of how to use GTK+ with Go.
- go-hashmap – A hash table in pure go as an experiment in Go performance
- golang-examples – A bunch of golang examples
- GolangSortingVisualization – A visualization of various sorting algorithms in Go
- golibs – A collection of tiny go packages (and also a test repo for various CI and coverage services)
- goplay – A bunch of random small programs in Go
- lifegame-on-golang – Game of Life in Go
- linear – Playing around with the linear algebra
- pl0 – PL/0 front end, compiler and VM. .
- project euler in go – Solutions to Project Euler in Go also
- shadergo – shader test using Go
- travisci-golang-example – Travis-CI example for Go
P2P and File Sharing
- DHT – Kademlia DHT node used by Taipei-Torrent, compatible with BitTorrent
- ed2kcrawler – eDonkey2000 link crawler
- gop2p – A simple p2p app to learn Go
- go-p2p – P2P module for blockchains and more
- GoTella – A Go implementation of the Gnutella Protocol
- Taipei-Torrent – A BitTorrent client
- Tendermint – P2P Byzantine-Fault-Tolerant consensus & blockchain stack
- wgo – A simple BitTorrent client based in part on the Taipei-Torrent and gobit code
- DHT – BitTorrent DHT Protocol && DHT Spider.
Programming
- go-clang – cgo bindings to the C-API of libclang
- godeferred – port of jsdeferred: http://cho45.stfuawsc.com/jsdeferred/
- go-galib – a library of Genetic Algorithms
- go-intset – a library to work with bounded sets of integers, including multiple alternative implementations
- go-parse – a Parsec-like parsing library
- sh – a shell/bash parser and formatter
- Shuffle – Implementation of the Fisher–Yates shuffle (or Knuth shuffle) in Go.
Resource Embedding
- fileb0x – Simple tool to embed files in go with focus on “customization” and ease to use.
- go-bindata – Package that converts any file into managable Go source code.
- go-resources – Unfancy resources embedding with Go.
- go.rice – go.rice is a Go package that makes working with resources such as html,js,css,images and templates very easy.
- statics – Embeds static resources into go files for single binary compilation + works with http.FileSystem + symlinks.
RPC
Scanner and Parser Generators
- ebnf2y – Utility for converting EBNF grammars into yacc compatible skeleton .y files.
- gocc – Go Compiler Compiler
- golex – Lex/flex like fast (DFA) scanners generator.
- gopp – Go Parser Parser
- goyacc – Goyacc is a version of yacc generating Go parsers.
- y – Package y converts .y (yacc) source files to data suitable for a parser generator.
- yy – yacc to yacc compiler.
- flexgo – A version of flex that can produce Go code.
- fsm – FSM (NFA, DFA) utilities.
- Ragel – State Machine Compiler
- lexmachine – Lexical Analysis Framework for Golang
Security
- acme – ACME certificate acquisition tool
- acra – SQL database protection suite: strong selective encryption, SQL injections prevention, intrusion detection system
- casbin – An authorization library that supports access control models like MAC, RBAC, ABAC
- docker-slim – Container security and optimization
- gryffin – A large scale security scanner by Yahoo!
- hyperfox – a security tool for proxying and recording HTTP and HTTPs communications on a LAN
- lego – Let\’s Encrypt client and ACME library
- webseclab – a sample set of web security test cases and a toolkit to construct new ones
Simulation Modeling
- godes – Library for building discrete event simulation models
Sorting
- funnelsort – Lazy funnel sort — a cache-oblivious sorting algorithm
- Sortutil – Nested, case-insensitive, and reverse sorting for Go.
- sortutil – Utilities supplemental to the Go standard “sort” package
- tarjan – Graph loop detection function based on Tarjan\’s algorithm
- timsort – Fast, stable sort, uses external comparator or sort.Interface
Source Code Management
- Gitfile – A lightweight package manager for installing git repos
-
go-deps – Analyzes and recursively installs Go package deps (library functionality similar to
go get
) - go-diff – A diff command for go languange showing semantic differences of two go source files.
- gogitver – Embeds a git tag (version string) into your application
- go-many-git – Manage and run commands across multiple git repositories
-
go-pkgs – Finds all matching packages in all of the GOPATH trees (library functionality similar to
go list all
) - go-vcs – clone and check out revs of VCS repositories (git and hg support)
- go-vcsurl – Lenient VCS repository URL parsing library
- hggofmt – A Mercurial/hg extension with a hook to
- nut – Nut is a tool to manage versioned Go source code packages, called “nuts”.
- vcstool – VCS abstraction tool
Storage
- Minio – Object Storage compatible with Amazon S3 API
- libStorage – an open source, platform agnostic, storage provisioning and orchestration framework, model, and API
- OpenEBS – Containerized, Open source block storage for your containers,integrated tightly into K8S and other environments and based on distributed block storage and containerization of storage control
Strings and Text
- allot – Placeholder and wildcard text parsing for CLI tools and bots
- awk – Easy AWK-style text processing in Go
- binarydist – Binary diff and patch
- Black Friday – A markdown processor
- codename-generator – A codename generator meant for naming software releases
- columnize – format slice or array into aligned columns
- csvplus – Extends the standard Go encoding/csv package with fluent interface, lazy stream operations, indices and joins.
- csvutil – A heavy duty CSV reading and writing library.
- dgohash – Collection of string hashing functions, including Murmur3 and others
- douceur – A simple CSS parser and inliner in Go.
- dsv – A library for working with delimited separated value (DSV).
- flux – Fluent Regular Expressions in golang
- genex – Expansion of Regular Expressions
- gettext-go – GNU\’s gettext support, written in pure Go
- gettext – Golang bindings for gettext; Feature complete, cgo
- go-colortext – Change the color of the text and background in the console, working both in Windows and other systems.
- go-guess – Go wrapper for libguess
- goagrep – fast fuzzy string matching using precomputation
- goini – A go library to parse INI files
- golorem – lorem ipsum generator
- go-migemo – migemo extension for go (Japanese incremental text search)
- go-ngram N-gram index for Go
- goregen – A Go library for generating random strings from regular expressions.
- goskirt – Upskirt markdown library bindings for Go
- gosphinx – A Go client interface to the Sphinx standalone full-text search engine
- govalidator – Package of string validators and sanitizers
- gpKMP – String-matching in Go using the Knuth–Morris–Pratt algorithm
- hangul – Handy tools to manipulate Korean character
- html2text – Golang HTML to text conversion library
- intern – Map strings to symbols for constant-time comparisons
- kasia.go – Templating system for HTML and other text documents
- kview – Simple wrapper for kasia.go templates. It helps to modularize content of a website
- liquid – A complete implementation of Shopify Liquid templates
- logparse – Parser for most common log formats
- NTemplate – Nested Templates
- parse – PEG parser that uses reflection to define grammar
- peg – Parsing Expression Grammer Parser
- pigeon – Parsing Expression Grammar (PEG) Parser generator for Go
- plural – No-fuss plurals for formatting both countable and continuous ranges of values.
- polyglot – String translation utilities for Go
- pretty.go – Pretty-printing for go values
- raymond – A complete handlebars implementation in Go.
- rubex – A simple regular expression library that supports Ruby\’s regex syntax. It is faster than Regexp.
- sanitize – Package sanitize provides functions for sanitizing html and text.
- scanner – A text scanner that parses primitive types, analogous to Java\’s
- segment – An implementation of Norvig\’s recursive word segmentation algorithm
- sprig – Template functions for Go templates.
- strftime – strftime implementation
- strit – Package strit introduces a new type of string iterator, as well as a number of iterator constructors, wrappers and combinators.
- strogonoff – Stenography with Go
- strutil – Package strutil collects utils supplemental to the standard strings package.
- text – Text paragraph wrapping and formatting
- Tideland golib – Stringex package for statistcal analysis
- useragent – User agent string parser
- xurls – Extract urls from text
Testing
- assert – Basic Assertion Library used along side native go testing, with building blocks for custom assertions
- assert – Assert for go test.
- assert – Handy assert package.
- assert – JUnit-like asserts with excellent error messages
- biff – Bifurcation testing framework, BDD compatible.
- charlatan – Tool to generate fake interface implementations for tests.
- conex – Docker containers for integration tests
- counterfeiter – Tool for generating self-contained and type-safe mocks.
- downtest – Automatically run tests for all known downstream consumers of a Go package.
- ginkgo – BDD Testing Framework for Go.
- go2xunit – Convert “go test -v” output to xunit XML output
- go-assert – Testing utils for Go.
- goautotest – Automatically run unit tests when code changes are made
- goblin – Minimal and Beautiful Go testing framework
- Gocheck – Rich test framework with suites, fixtures, assertions, good error reporting, etc
-
GoConvey – Browser-based reporting, uses
go test
, supports traditional Go tests, clean DSL - gocov – Code coverage testing/analysis tool
- gomega – Ginkgo\’s Preferred Matcher Library.
- gomock – a mocking framework for Go.
- GoSpec – a BDD framework
- gospecify – another BDD framework
- go-stat – performant instrumentation/profiling for Go
- go-tap – TAP (Test Anything Protocol) parser in Go
- gotest.tools – a collection of packages for writing readable tests
- gotestsum – a test runner with customizable and colored output
- gounit – xunit for Go
- GSpec – Expressive, reliable, concurrent and extensible Go test framework that makes it productive to organize and verify the mind model of software.
- httpexpect – Concise, declarative, and easy to use end-to-end HTTP and REST API testing
- Nitro – A quick and simple profiler For Go
- mspec – BDD framework that frees you to Stub and Spec your code first with natural BDD language.
- muxy – Simulating real-world distributed system failures.
- Pegomock – a mocking framework based on golang/mock, but uses a DSL closely related to Mockito.
- terst – A terse, easy-to-use testing library for Go
- test2doc – Generate documentation for your go units from your unit tests.
- testfixtures – Rails\’ like test fixtures for testing database driven apps.
- testflight – Painless http testing in Go
- Testify – A set of packages that provide many tools for testifying that your code will behave as you intend.
- ut – Awesome mocks without magic.
Validation
- validator – Go Struct and Field validation, including Cross Field, Cross Struct, Map, Slice and Array diving
- validation – Simple independent struct/key-value validation
Version Control
- git (in go) – Minimal working git client in Go
- gogs – Self-hosting Git Server in Go
- semver – Semantic Versioning (SemVer) library
Virtual Machines and Languages
- agora – A dynamically typed, garbage collected, embeddable programming language built with Go
- anko – Scriptable interpreter written in golang
- forego – Forth virtual machine
- Gelo – Extensible, embeddable interpreter
- GoAwk – An implementation of awk in golang.
- GoEmPHP – This package is built for Embedding PHP into Go
- Goja – ECMAScript 5.1(+) implementation written in Go (otto fork with byte code compiler)
- goenv – Create an isolated environment where you install Go packages, binaries, or even C libraries. Very similar to virtualenv for Python.
- GoForth – A simple Forth parser
- golemon – A port of the Lemon parser-generator
- GoLightly – A flexible and lightweight virtual machine with runtime-configurable instruction set
- goll1e – An LL(1) parser generator for the Go programming language.
- Golog – Prolog interpreter in Go
- go-lua – Shopify\’s lua interpreter
- golua – A fork of GoLua that works on current releases of Go
- gomruby – mruby (mini Ruby) bindings for Go
- gopher-lua – A Lua 5.1 VM and compiler written in Go
- go-php – PHP bindings for Go
- go-python – go bindings for CPython C-API
- gotcl – Tcl interpreter in Go
- go.vm – Simple virtual machine which interprets bytecode.
- v8 – V8 JavaScript engine bindings for Go (supports V8 builds at least up to 5.8.244)
- go-v8 – V8 JavaScript engine bindings for Go
- LispEx – A dialect of Lisp extended to support for concurrent programming, written in Go.
- meme – Scheme interpreter in Go
- Minima – A language implemented in Go
- ngaro – A ngaro virtual machine to run retroForth images
- otto – A JavaScript parser and interpreter written natively in Go
- RubyGoLightly – An experimental port of TinyRb to Go
Web Applications
- Presento – The simplest possible cross-platform remote control for the presentations
- Caddy – A fast, capable, general-purpose HTTP/2 web server that\’s easy to use
- Dataflowkit – Web scraping Service to turn websites into structured data.
- Digestw – A Web Application – Twitter\’s Timeline Digest
- fabio – A fast zero-conf load balancing HTTP router for microservices.
- fourohfourfound – A fallback HTTP server that may redirect requests with runtime configurable redirections
- Fragmenta – A CMS built in Go
- freegeoip – IP geolocation web service (web server of freegeoip.net)
- goals-calendar – A web-based Seinfeld calendar implemented in Go
- goblog – A static blog engine
- gocrawl – A polite, slim and concurrent web crawler.
- goflash – Flash player implementation in Go language
- gogallery – simple web server with an emphasis on easily browsing images
- gojekyll – A golang clone of the Jekyll static site generator
- goof – A simple http server to exchange files over http (upload/download)
- gopages – A php-like web framework that allows embedding Go code in web pages
- go_spider – A flexible ,modularization and concurrent web crawler framework.
- GoURLShortener – A frontend for the http://is.gd/ URL shortener
- gowall – A website and user system
- httpfolder – A http server to exchange files over http with basic authentication (upload/download)
- Hugo – A fast and flexible static site generator implemented in Go
- Já Vai Tarde – Unfollows monitoring for Twitter
- kurz.go – a url shortener based on web.go and redis
- Monsti – Resource friendly flat file CMS for private and small business sites.
- now.go – A simple HTTP-based to-do queue.
- Peach – A web server for multi-language, real-time synced and searchable documentation.
- rabbitmq-http – REST API for RabbitMQ
- serve-files – Far-future and gzip wrapper around the standard net/http server.
- sf_server – a tiny send file server and client
- SuperSaaS API Client – HTTP client library for the supersaas.com scheduling/bookings/appointments API
- Tideland golib – Web package for REST request handling
- Vantaa – A modular blogging API engine written in Go, Neo4j and Polymer.
- websiteskeleton – Simple net/http website skeleton
- webtf – Web app to graphical visualization of twitter timelines using the HTML5
- Wikifeat – Extensible wiki system using CouchDB written in Golang
- Freyr – Server for storing and serving readings from plant environment sensors. Integrates Golang API with ReactJS web app; uses Docker for testing/deployment.
- Rickover – Job queue with a HTTP API, backed by Postgres
Web Libraries
Authentication
- goth – Package goth provides a simple, clean, and idiomatic way to write authentication packages for Go web applications
- authcookie – Package authcookie implements creation and verification of signed authentication cookies.
- dgoogauth – Go port of Google\’s Authenticator library for one-time passwords
- goauth – A library for header-based OAuth over HTTP or HTTPS.
- GOAuth – OAuth Consumer
- go-http-auth – HTTP Basic and HTTP Digest authentication
- Go-OAuth – OAuth 1.0 client
- goha – Basic and Digest HTTP Authentication for Go http client
- hero – OAuth server implementation – be an OAuth provider with Go
- httpauth-go – Package httpauth provides utilities to support HTTP authentication policies. Support for both the basic authentication scheme and the digest authentication scheme are provided.
- httpauth – HTTP session (cookie) based authentication and authorization
- oauth1a – OAuth 1.0 client library
- OAuth Consumer – OAuth 1.0 consumer implementation
- otp – HOTP and TOTP library with command line replacement for Google Authenticator
- securecookie – Encode and Decode secure cookies
- totp – Time-Based One-Time Password Algorithm, specified in RFC 6238, works with Google Authenticator
- go-otp – Package go-otp implements one-time-password generators used in 2-factor authentication systems like RSA-tokens. Currently this supports both HOTP (RFC-4226), TOTP (RFC-6238) and Base32 encoding (RFC-3548) for Google Authenticator compatibility
DOM handling
- Cascadia – CSS selector library
- GoQuery – jQuery-like DOM manipulation library, using Go\’s experimental HTML package.
- goq – jQuery-like declarative struct tag scraping and unmarshaling based on GoQuery.
- html-query – A fluent and functional approach to querying HTML.
- HTML Transform – A CSS selector based html scraping and transformation library
Frameworks and Toolkits
- aah – A scalable, performant, rapid development Web framework for Go.
- Aero – Fast and secure web server for Go.
- Air – An ideal RESTful web framework for Go.
- alien – A lightweight and fast http router
- app.go – Web framework for google app engine
- arasu – A Lightning Fast Web Framework written in Go & Dart
- Beego – Beego is an open source version of the scalable, non-blocking web framework.
-
browserspeak – Generate HTML templates, CSS or SVG without writing
<
or>
- httpcoala – Library for request coalescing – handy for reverse proxies.
- falcore – Modular HTTP server framework
- fcgi_client – Go fastcgi client with fcgi params support
- florest – High-performance workflow based REST API framework in Go
- forgery – A clone of the superb Node.js web framework Express.
- gramework – The truly fastest web framework for Go. Battle tested, highly effective baseline for your web apps.
- Gin Web Framework – Martini-like API and httprouter gives it good performance.
- Goal – A toolkit for high productivity web development in Go language built around the concept of code generation.
- Go-Blog – Blog framework written in Go
- go-fastweb – aims to be a simple, small and clean MVC framework for go
- goku – a Web Mvc Framework for Go, mostly like ASP.NET MVC.
- Golanger – Golanger Web Framework is a lightweight framework for writing web applications in Go.
- Goldorak.Go – a web miniframework built using mustache.go, web.go and Go-Redis
- go-restful – lean package for building REST-style Web Services
- GoRest – An extensive configuration(tags) based RESTful style web-services framework.
- go-rest – A small and evil REST framework for Go
- gorilla – Gorilla web toolkit
- GoSrv – A Go HTTP server that provides simple command line functionality, config loading, request logging, graceful connection shutdown, and daemonization.
- go-start – A high level web-framework for Go
- go-urlshortener – interface to google\’s urlshorten API
- goweb – Lightweight RESTful web framework for Go providing Ruby on Rails style routing
- go-webproject – Modular web application framework and app server
- Gowut – Go Web UI Toolkit is a full-featured, easy to use, platform independent Web UI Toolkit written in pure Go.
- HttpRouter – A high performance HTTP request router that scales well
- limiter – Simple rate limter middleware for Go
- Macaron – Modular web framework in Go
- mango – Mango is a modular web-application framework for Go, inspired by Rack, and PEP333.
- Martini deprecated – Martini is a popular, lightweight, extensible package for writing modular web apps/services in Go
- Negroni – Idiomatic middleware for Go
- restclient – Client library for interacting with RESTful APIs.
- resty – REST client library inspired by Ruby rest-client.
- Revel – High productivity web framework modeled on Play! Framework
- Ringo – Lighweight MVC web framework inspired by Rails, Gin.
- sawsij – Provides a small, opinionated web framework.
- Tango – Micro-kernel & pluggable web framework for Go
- Tiger Tonic – framework for building JSON web services inspired by Dropwizard
- trinity – MVC framework
- Utron – MVC Framework
- Violetear – HTTP router
- web.go – a simple framework to write webapps
- wfdr – Simple web framework designed for and written in go. Works with other languages as well, but not as well.
- xweb – A web framework for Go. Just like Struts for Java.
HTML forms
- form – Complete bidirectional HTML form encoder & decoder (x-www-form-urlencoded) for arbitrary data (package encoding compatible)
- gforms – HTML forms for Go
- Go-FORM-it – Go library for easy and highly-customizable forms creation and template rendering.
- GoForms – Form data validation, cleaning and error reporting – a la django.forms
- htmlfiller – Fills in html forms with default values and errors a la Ian Bicking\’s htmlfill for Python
- MonstiForm – HTML form generator and validator library
- revel-csrf – Cross-Site Request Forgery (CSRF) attacks prevention for the Revel framework
- xsrftoken – A package for generating and validating tokens used in preventing XSRF attacks
Public API Wrappers
- adn – Interface to the App.net API
- anaconda – Client library for the Twitter 1.1 API
- ddg – DuckDuckGo API interface
- facebook – Up-to-date facebook graph API client. Handy and flexible
- filepicker-go – Go library for the Filepicker\’s REST API
- firebase – Client library for the Firebase REST API
- gh – Scriptable server and net/http middleware for GitHub Webhooks API
- github – Go library for accessing the GitHub REST API v3
- githubql – Go library for accessing the GitHub GraphQL API v4
- gobo – Client library for Sina Weibo
- gocaptcha – gocaptcha provides easy access to the reCaptcha API in go
- go-dealmap – Go library for accessing TheDealMap\’s API
- go-dropbox – API library for dropbox
- go-flickr – A wrapper for Flickr\’s API
- go-get-youtube – A simple library+client for fetching meta data of, and downloading Youtube videos
- go-gravatar – Wrapper for the Gravatar API
- go-hummingbird – Go library for accessing the Hummingbird.me API
- go-libGeoIP – GO Lib GeoIP API for Maxmind
- gominatim – Go library to access nominatim geocoding services
- gomojo – Instamojo API wrapper
- gomwapi – Access mediawiki contents like wikipedia, wiktionary in golang
- go-myanimelist – Go library for accessing the MyAnimeList API
- googtrans – unofficial go bindings for Google Translate API v2
- go-recaptcha – Handles reCaptcha form submissions in Go
- gorecurly – A Client app to use with Recurly\’s api
- go.strava – Official client library for the Strava V3 API
- go.stripe – a simple credit card processing library for Go using the Stripe API
- Gotank – Searchify\’s Go client for the IndexTank full-text search API
- go-tripit – Go API library for the TripIt web services
- GoTwilio – Twilio library for Go (golang). Very basic at the moment
- gravatar – Gravatar image/profile API library
- jsonapi – Generate JSON API from Go structs
- postmark – Access postmark API from Go
- reddit.go – Client library for Reddit API
- shorturl – Generic implementation for interacting with various URL shortening services
- Stack on Go – Go wrapper for Stack Exchange API
- stripe – Official Stripe client library
- SocialSharesCount – Wrapper API on multiple social websites to get URL share statistics
- twilio – Simple Twilio API wrapper
- twittergo – Client library for Twitter\’s API
- cloudcomb-go-sdk – Go client library for CloudComb
Other
- adhoc-http – Quick & dirty HTTP static file server
- assets – Helps prepares CSS and JS files for development and production of Go web apps.
- bwl – a set of libraries to help build web sites
- captcha – Image and audio captcha generator and server
- gaerecords – Lightweight wrapper around appengine/datastore providing Active Record and DBO style management of data
- gcd – provides helpful functions to work with Google Cloud DataStore.
- get2ch-go – a library to access the 2channel Japanese web bulletin board
- gofeed – Parse RSS and Atom feeds in Go
- go-gzip-file-server – A net.http.Handler similar to FileServer that serves gzipped content
- gohaml – An implementation of the popular XHTML Abstraction Markup Language using the Go language.
- go-httpclient – a Go HTTP client with timeouts
- gojwt – Json Web Tokens for Go
- go-pkg-rss – a packages that reads RSS and Atom feeds
- gorefit – A library for theming existing websites
- goreman – foreman clone
- GoRequest – Simplified HTTP client with rich features such as proxy, timeout, and etc. ( inspired by nodejs SuperAgent )
- goroute – A very simple URL router based on named submatches of regular expression that works well with http.Handler .
- gorouter – Simple router for go to process url variables
- go-rss – Simple RSS parser and generator
- go-rss – Simple RSS parser, tested with WordPress feeds.
- goscribble – An MPD Audioscrobble
- go-twitter – another Twitter client
- go-twitter-oauth – a simple Twitter client (supports OAuth)
- grender – Go static site generator
- halgo – HAL-compliant API client and serialisation library.
- http-gonsole – Speak HTTP like a local. (the simple, intuitive HTTP console, golang version)
- httprpc – HTTP RPC codecs (json2, soap, rest)
- HypeCMS – A flexible CMS built with Go and MongoDb.
- Kontl – A client for kon.tl\’s URL shortening service
- mustache.go – an implementation of the Mustache template language
- muxer – Simple muxer for a Go app without regexp
- Optimus Sitemap Generator – A universal XML sitemap generator
- passwordreset – Creation and verification of secure tokens useful for implementation of “reset forgotten password” feature in web applications.
- pat – A Sinatra style pattern muxer
- persona – remote verification API for persona
- plex – simple, small, light, regexp http muxer with chaining
- purell – tiny Go library to normalize URLs
- pusher.go – HTTP Server Push module for the standard http package
- rest2go – Based on rest.go, forked for improvements and REST consistency
- rest.go (forked) – forked rest.go for improvements and REST consistency
- resty – Simple HTTP and REST client for Go inspired by Ruby rest-client.
- robotstxt – The robots.txt exclusion protocol implementation. Allows to parse and query robots.txt file.
- seshcookie – A web session library inspired by Beaker
- soy – A Go implementation for Soy templates (Google Closure templates). High performance and i18n.
- user_agent – An HTTP User-Agent parser
- webtestutil – Web and HTTP functional testing utilities. Includes Gorilla testing support.
- aop – Aspect Oriented Programming For Go.
- yt2pod – Daemon that monitors YouTube channels and publishes audio podcasts of them
Windows
- gform – An easy to use Windows GUI toolkit for Go
- go-ole – win32 ole implementation for golang
- go-Windows-begin – for the absolute Windows-Go beginner
- w32 – Windows API wrapper for Go.
- walk – “Windows Application Library Kit” for the Go Programming Language
- Windows Command Line Shutdown – A tool to shutdown Windows Computer from Command Prompt
Unix
- inspect – Linux and MacOSX systems monitoring and diagnostics
- unixsums – Legacy Unix checksums: cksum, sum
Unsorted; please help!
The following entries have not been filed. Please help by putting these in relevant categories.
- GoBot – PoC Go HTTP Botnet
- ebml-go – EBML decoder
- go-bindata – Converts any file into manageable Go source code for embedding binary data into a Go program.
- consistent – Consistent hashing with bounded loads.
- goconsistenthash – Consistent hashing library (based on http://www.lexemetech.com/2007/11/consistent-hashing.html)
-
go-cron – A small cron job system to handle scheduled tasks, such as optimizing databases or kicking idle users from chat. The cron.go project was renamed to this for
go get
compatibility. - godebiancontrol – Golang debian control file parser
- go-gmetric – Ganglia gmetric protocol support
- gographviz – Graphviz DOT language parser for golang
- godotviz – Rendering graphics files from “DOT language”. Written in golang
- dotviz-server – WebBased DOT language visualization tool written in go
- goseq – command line tool, written in Go, for creating sequence diagrams using a text-based description language.
- golor – golor is a command line tool for golang source code coloring
- gopcapreader – Presents realtime pcap data as io.Reader objects
- go.psl – Go regdom-libs/public suffix list
- go-webfinger – Simple Client Implementation of WebFinger
- img-LinuxFr.org – A reverse-proxy cache for external images used on LinuxFr.org
- seed – Easily seed PRNGs with some entropy
- spellabc – Package spellabc implements spelling alphabet code word encoding.
- Twackup – Backs up your tweets into local files
- Tasks – A simplistic todo list manager written in Go
- one-file-pdf – A minimalist Go PDF writer in <2K lines and 1 file