Package atime provides a platform-independent way to get atimes for files.

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.

flock implements a thread-safe file lock. It also includes a non-blocking TryLock function to allow locking without blocking execution.

This package provides helpers for generating Go assembler ABI0 code.

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

Package stack implements utilities to capture, manipulate, and format call stacks. It provides a simpler API than package runtime. The implementation takes care of the minutia and special cases of interpreting the program counter (pc) values returned by runtime.Callers.

Suture provides Erlang-ish supervisor trees for Go. "Supervisor trees" -> "sutree" -> "suture" -> holds your code together when it's trying to die.

It is intended to deal gracefully with the real failure cases that can occur with supervision trees (such as burning all your CPU time endlessly restarting dead services), while also making no unnecessary demands on the "service" code, and providing hooks to perform adequate logging with in a production environment

doublestar is a Go implementation of path pattern matching and globbing with support for "doublestar" patterns.

This package provides a wrapper for the Pluggable Authentication Modules application API.

This package provides a filesystem glob API. It uses gobwas/glob underneath and returns only matching files or directories, depending on the configuration.

This package provides a collection Golang implementation defined in specification-runtime-spec.

Package colorprofile provides a way to downsample ANSI escape sequence colors and styles automatically based on output, environment variables, and Terminfo databases.

This package provides a golang wrapper for parsing gocui keybindings.

This package provides a little terminal spinner library.

This package provides an alternative implementation of regexp, with some code optimisations to make it run faster.

This package provides an implementation of the BARE https://baremessages.org/ message format for Golang.

This package provides basic image processing functions including resize, rotate, crop, and various adjustments. This is a fork maintained by Kovid Goyal for use in Kitty.

This provides helper functions for dealing with signals across various operating systems.

Package vaxis is a terminal user interface for modern terminals. It supports supports modern terminal features, such as styled underlines and graphics. A widgets package is provided with some useful widgets.

GoLog is a level-based logger written in Go.

Package percent escapes strings using percent-encoding.

This is a Go package that implements decoding of JSON5.

It's an alternative fork of https://github.com/titanous/json5.

Package kyaml contains libraries for reading and writing Kubernetes Resource configuration as YAML.

Diskv (disk-vee) is a simple, persistent key-value store written in the Go language. It starts with a simple API for storing arbitrary data on a filesystem by key, and builds several layers of performance-enhancing abstraction on top. The end result is a conceptually simple, but highly performant, disk-backed storage system.