Bit-packing and Compression

• bingo - Fast, zero-allocation, lexicographical-order-preserving packing of native types to bytes.
• binpacker - Binary packer and unpacker helps user build custom binary stream.
• bit - Golang set data structure with bonus bit-twiddling functions.
• crunch - Go package implementing buffers for handling various datatypes easily.
• go-ef - A Go implementation of the Elias-Fano encoding.
• roaring - Go package implementing compressed bitsets.
• bitmap - Dense, zero-allocation, SIMD-enabled bitmap/bitset in Go.
• bitset - Go package implementing bitsets.
• bloom - Go package implementing Bloom filters.
• bloom - Bloom filters implemented in Go.
• bloom - Golang Bloom filter implementation.
• bloomfilter - Yet another Bloomfilter implementation in Go, compatible with Java's Guava library.
• boomfilters - Probabilistic data structures for processing continuous, unbounded streams.
• cuckoo-filter - Cuckoo filter: a comprehensive cuckoo filter, which is configurable and space optimized compared with other implements, and all features mentioned in original paper are available.
• cuckoofilter - Cuckoo filter: a good alternative to a counting bloom filter implemented in Go.
• ring - Go implementation of a high performance, thread safe bloom filter.
• algorithms - Algorithms and data structures.CLRS study.
• go-datastructures - Collection of useful, performant, and thread-safe data structures.
• gods - Go Data Structures. Containers, Sets, Lists, Stacks, Maps, BidiMaps, Trees, HashSet etc.
• gostl - Data structure and algorithm library for go, designed to provide functions similar to C++ STL.
• gloop - Convenient looping using Go's range-over-func feature.
• goterator - Iterator implementation to provide map and reduce functionalities.
• iter - Go implementation of C++ STL iterators and algorithms.
• cmap - a thread-safe concurrent map for go, support using interface{} as key and auto scale up shards.
• concurrent-swiss-map - A high-performance, thread-safe generic concurrent hash map implementation with Swiss Map.
• dict - Python-like dictionaries (dict) for Go.
• go-shelve - A persistent, map-like object for the Go programming language. Supports multiple embedded key-value stores.
• goradd/maps - Go 1.18+ generic map interface for maps; safe maps; ordered maps; ordered, safe maps; etc.
• hmap - HMap is a concurrent and secure, generic support Map implementation designed to provide an easy-to-use API.
• concurrent-writer - Highly concurrent drop-in replacement for bufio.Writer.
• count-min-log - Go implementation Count-Min-Log sketch: Approximately counting with approximate counters (Like Count-Min sketch but using less memory).
• fsm - Finite-State Machine package.
• genfuncs - Go 1.18+ generics package inspired by Kotlin's Sequence and Map.
• go-generics - Generic slice, map, set, iterator, and goroutine utilities.
• go-geoindex - In-memory geo index.
• go-rampart - Determine how intervals relate to each other.
• go-rquad - Region quadtrees with efficient point location and neighbour finding.
• go-tuple - Generic tuple implementation for Go 1.18+.
• go18ds - Go Data Structures using Go 1.18 generics.
• gofal - fractional api for Go.
• gogu - A comprehensive, reusable and efficient concurrent-safe generics utility functions and data structures library.
• gota - Implementation of dataframes, series, and data wrangling methods for Go.
• hide - ID type with marshalling to/from hash to prevent sending IDs to clients.
• hyperloglog - HyperLogLog implementation with Sparse, LogLog-Beta bias correction and TailCut space reduction.
• quadtree - Generic, zero-alloc, 100%-test covered quadtree.
• slices - Pure, generic functions for slices.
• nan - Zero allocation Nullable structures in one library with handy conversion functions, marshallers and unmarshallers.
• null - Nullable Go types that can be marshalled/unmarshalled to/from JSON.
• typ - Null Types, Safe primitive type conversion and fetching value from complex structures.
• deque - A highly optimized double-ended queue.
• deque - Fast ring-buffer deque (double-ended queue).
• dqueue - Simple, in memory, zero dependency and battle tested, thread-safe deferred queue.
• goconcurrentqueue - Concurrent FIFO queue.
• hatchet - Distributed, Fault-tolerant task queue.
• list - A generic, thread-safe doubly linked list with full iterator support and an intrusive singly linked list for embedded use; a feature-rich replacement for container/list.
• memlog - An easy to use, lightweight, thread-safe and append-only in-memory data structure inspired by Apache Kafka.
• queue - Multiple thread-safe, generic queue implementations for Go.
• dsu - Disjoint Set data structure implementation in Go.
• golang-set - Thread-Safe and Non-Thread-Safe high-performance sets for Go.
• goset - A useful Set collection implementation for Go.
• set - Simple set data structure implementation in Go using LinkedHashMap.
• bleve - Modern text indexing library for go.
• go-adaptive-radix-tree - Go implementation of Adaptive Radix Tree.
• go-edlib - Go string comparison and edit distance algorithms library (Levenshtein, LCS, Hamming, Damerau levenshtein, Jaro-Winkler, etc.) compatible with Unicode.
• levenshtein - Levenshtein distance and similarity metrics with customizable edit costs and Winkler-like bonus for common prefix.
• levenshtein - Implementation to calculate levenshtein distance in Go.
• mspm - Multi-String Pattern Matching Algorithm for information retrieval.
• parsefields - Tools for parse JSON-like logs for collecting unique fields and events.
• ptrie - An implementation of prefix tree.
• trie - Trie implementation in Go.
• graphlib - Topological sort lib,Sorting and pruning of DAG graphs.
• hashsplit - Split byte streams into chunks, and arrange chunks into trees, with boundaries determined by content, not position.
• merkle - Space-efficient computation of Merkle root hashes and inclusion proofs.
• skiplist - Very fast Go Skiplist implementation.
• skiplist - Skiplist implementation in Go.
• treemap - Generic key-sorted map using a red-black tree under the hood.
• ordered-concurrently - Go module that processes work concurrently and returns output in a channel in the order of input.
• parapipe - FIFO Pipeline which parallels execution on each stage while maintaining the order of messages and results.
• pipeline - An implementation of pipelines with fan-in and fan-out.
• pipelines - Generic pipeline functions for concurrent processing.

← All categories