Package pool contains helpers for pooling structures distinguishable by size.

This library defines functions to perform string interning in Go, storing only one copy of each unique string in memory. All functions may be called concurrently with themselves and each other.

This package provides an API for finding and listing processes in a platform-agnostic way.

reflectwalk is a Go library for "walking" a value in Go using reflection, in the same way a directory tree can be "walked" on the file system. Walking a complex structure can allow you to do manipulations on unknown structures such as those decoded from JSON.

Package deque provides a fast ring-buffer deque (double-ended queue) implementation for Golang.

It generalizes a queue and a stack, to efficiently add and remove items at either end with O(1) performance. Queue (FIFO) operations are supported using PushBack and PopFront. Stack (LIFO) operations are supported using PushBack and PopBack.

go-redis is the official Redis client library for the Go programming language. It offers a straightforward interface for interacting with Redis servers.

Package pretty provides pretty-printing for Go values. This is useful during debugging, to avoid wrapping long output lines in the terminal.

It provides a function, Formatter, that can be used with any function that accepts a format string. It also provides convenience wrappers for functions in packages fmt and log.

Package sqlstruct provides some convenience functions for using structs with the Go standard library's database/sql package.

This package provides schema of the external API types that are served by the Kubernetes API server.

This is a Go library for detecting the user's home directory without the use of cgo, so the library can be used in cross-compilation environments.

Usage is simple, just call homedir.Dir() to get the home directory for a user, and homedir.Expand() to expand the ~ in a path to the home directory.

Why not just use os/user? The built-in os/user package requires cgo on Darwin systems. This means that any Go code that uses that package cannot cross compile. But 99% of the time the use for os/user is just to retrieve the home directory, which we can do for the current user without cgo. This library does that, enabling cross-compilation.

This package provides utilities for manipulating POSIX capabilities.

PG* is a protoc plugin library for efficient proto-based code generation.

This package implements the Time-Stamp Protocol (TSP) as specified in RFC3161 (Internet X.509 Public Key Infrastructure Time-Stamp Protocol).

This package provides a command-line color library with 16/256/True color support, universal API methods and Windows support.

Features:

• supports rich color output: 16-color (4-bit), 256-color (8-bit), true color (24-bit, RGB)

• support converts HEX HSL value to RGB color

• generic API methods: Print, Printf, Println, Sprint, Sprintf

• supports HTML tag-style color rendering, such as <green>message</> <fg=red;bg=blue>text</>

• basic colors: Bold, Black, White, Gray, Red, Green, Yellow, Blue, Magenta, Cyan

• additional styles: Info, Note, Light, Error, Danger, Notice, Success, Comment, Primary, Warning, Question, Secondary

• support by set NO_COLOR for disable color or use FORCE_COLOR for force open color render

• support RGB, 256, 16 color conversion

Go-Logging implements a logging infrastructure for Go. Its output format is customizable and supports different logging backends like syslog, file and memory. Multiple backends can be utilized with different log levels per backend and logger.

This package is an extension for the standard sync package and provides the following concurrent data structures for Go: a concurrent counter, concurrent hash table, multiple concurrent queues and mutex.

This package provides an utility to work with vellum FST files.

This package provides a collection of tools for working with the OCI runtime specification. To build from source code, runtime-tools requires Go 1.10.x or above.

Package queue provides a fast, ring-buffer queue based on the version suggested by Dariusz Górecki. Using this instead of other, simpler, queue implementations (slice+append or linked list) provides substantial memory and time benefits, and fewer GC pauses.

This package is a Go implementation of the zap file format. The zap file format is used by the bleve search engine to store its indexes. It is documented at https://github.com/blevesearch/zapx/blob/master/zap.md. It was originated as https://github.com/blevesearch/zap.

Package zstd is a collection of extensions to Go's standard library.

Package errors provides errors that have stack-traces. It provides the type *Error which implements the standard golang error interface, so you can use this library interchangeably with code that is expecting a normal error return.

This package defines two types for managing concurrency: throttle, which allows calls to a function to be coalesced among multiple concurrent goroutines and trigger, that implements channel-based condition variable.

This package implements a functionality to modify/update field tags in structs making it easy to update, add or delete the tags in a struct field with possibility to add and remove tag options. It's intended to be used by an editor, but also has modes to run it from the terminal. This package provides a command line interface (CLI) tool.