Viper is a complete configuration solution for Go applications including 12-Factor apps. It is designed to work within an application, and can handle all types of configuration needs and formats.

This package provides a library for building powerful interactive prompts inspired by python-prompt-toolkit, making it easier to build cross-platform command line tools using Go.

This package provides a fast and simple way to set a value in a JSON document.

Shellquote provides utilities for joining/splitting strings using sh's word-splitting rules.

It's an alternative fork of https://github.com/kballard/go-shellquote.

Package channels provides a collection of helper functions, interfaces and implementations for working with and extending the capabilities of golang's existing channels. The main interface of interest is Channel, though sub-interfaces are also provided for cases where the full Channel interface cannot be met (for example, InChannel for write-only channels).

Package btrfs provides bindings for working with btrfs partitions from Go. The Linux kernel headers are only required on compilation time, not on run time.

This is a package extracted from go-ipfs. Its purpose to be used to compare a set of keys based on a given metric. The primary metric used is XOR, as in kademlia.

This package provides a native Go clean room implementation of the Porter Stemming Algorithm.

Semver is a library for Semantic versioning written in Go.

go-datastructures is a collection of useful, performant, and thread-safe Go data structures.

It includes:

• Augmented Tree - Interval tree for collision in n-dimensional ranges. Implemented via a red-black augmented tree.

• Bitarray - Bitarray used to detect existence without having to resort to hashing with hashmaps. Requires entities have a uint64 unique identifier. Two implementations exist, regular and sparse.

• Futures - A helpful tool to send a broadcast message to listeners.

• Queue - Package contains both a normal and priority queue. Both implementations never block on send and grow as much as necessary.

• Fibonacci Heap - A standard Fibonacci heap providing the usual operations. Can be useful in executing Dijkstra or Prim's algorithms in the theoretically minimal time.

• Range Tree - Useful to determine if n-dimensional points fall within an n-dimensional range.

• Set - Set implementation which accepts items of type interface and includes only a few methods.

• Threadsafe - A package that is meant to contain some commonly used items but in a threadsafe way.

• AVL Tree - This is an example of a branch copy immutable Adelson-Velsky and Landis Balanced Binary Search Trees.

• X-Fast Trie - An interesting design that treats integers as words and uses a trie structure to reduce time complexities by matching prefixes.

• Y-Fast Trie - An extension of the X-Fast trie in which an X-Fast trie is combined with some other ordered data structure to reduce space consumption and improve CRUD types of operations.

• Fast Integer Hashmap - A datastructure used for checking existence but without knowing the bounds of your data. If you have a limited small bounds, the bitarray package might be a better choice.

• Skiplist - An ordered structure that provides amortized logarithmic operations but without the complication of rotations that are required by BSTs.

• Sort - The sort package implements a multithreaded bucket sort that can be up to 3x faster than the native Golang sort package.

• Numerics - Early work on some nonlinear optimization problems. The initial implementation allows a simple use case with either linear or nonlinear constraints.

• B+ Tree - Initial implementation of a B+ tree. Delete method still needs added as well as some performance optimization.

• Immutable B Tree - A btree based on two principles, immutability and concurrency.

• Ctrie - A concurrent, lock-free hash array mapped trie with efficient non-blocking snapshots.

• Dtrie - A persistent hash trie that dynamically expands or shrinks to provide efficient memory allocation.

• Persistent List - A persistent, immutable linked list.

• Simple Graph - A mutable, non-persistent undirected graph where parallel edges and self-loops are not permitted.

Package editorconfig allows parsing and using EditorConfig files, as defined in https://editorconfig.org/.

This package implements a publish–subscribe pattern.

This package implements a functionalit to list currently running Go processes.

Java properties scanner for Go

This library is an implementation of backoff algorithm for retrying operations. It respects context.Context natively, and the critical notifications are done through channel operations, allowing you to write code that is both more explicit and flexibile.

Package argv parses command line string into arguments array using the bash syntax.

Package ioutil contains extensions for the io package.

This package provides an utility for timezone manipulation, implementing the following features:

• this library uses only the standard package

• supports getting offset from timezone abbreviation, which is not supported by the time package

• determine whether the specified time.Time is daylight saving time

• change the location of time.Time by specifying the timezone

gofpdi allows you to import an existing PDF into a new PDF.

Chroma takes source code and other structured text and converts it into syntax highlighted HTML, ANSI-coloured text, etc.

The terminfo package implements terminfo database reading for Go.

This package implements directed acyclic graphs (DAGs).

This package provides basic types for OSM elements (nodes/ways/relations/etc).

It include the following submodules:

• parser/changeset - a parser for OSM changeset files

• parser/diff - a parser for OSM diff files (.osc)

• parser/pbf - an efficient parser for OpenStreetMap PBF files

• replication - basic types for replication of OSM data

• replication/changeset - functions for downloading OSM changeset files

• replication/diff - functions for downloading OSM diff files

• state - functions for reading and writing diff status files

winquit is a golang module that supports graceful shutdown of Windows applications through the sending and receiving of Windows quit events on Win32 message queues. This allows golang applications to implement behavior comparable to SIGTERM signal handling on UNIX derived systems. Additionally, it supports the graceful shutdown mechanism employed by Windows system tools, such as taskkill.exe.