Gocc is a compiler kit for Go written in Go. Gocc generates lexers and parsers or stand-alone DFAs or parsers from a BNF. Lexers are DFAs, which recognise regular languages. Gocc lexers accept UTF-8 input. Gocc parsers are PDAs, which recognise LR-1 languages. Optional LR1 conflict handling automatically resolves shift / reduce and reduce / reduce conflicts.

ll is a high-performance, production-ready logging library for Go, designed to provide hierarchical namespaces, structured logging, middleware pipelines, conditional logging, and support for multiple output formats, including text, JSON, colorized logs, and compatibility with Go’s slog. It’s ideal for applications requiring fine-grained log control, extensibility, and scalability.

Package pflag is a drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags. It is compatible with the GNU extensions to the POSIX recommendations for command-line options. This is an actively maintained fork of https://github.com/ogier/pflag.

A minimal QPACK (RFC 9204) implementation in Go. It is minimal in the sense that it doesn't use the dynamic table at all, but just the static table and (Huffman encoded) string literals. Wherever possible, it reuses code from the HPACK implementation in the Go standard library.

Gogoprotobuf is a fork of golang/protobuf with extra code generation features. This code generation is used to achieve:

• fast marshalling and unmarshalling

• more canonical Go structures

• goprotobuf compatibility

• less typing by optionally generating extra helper code

• peace of mind by optionally generating test and benchmark code

• other serialization formats

Helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.

Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

Helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.

Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

This package provides features beyond the defacto YAML library including:

• Pretty format for error notifications

• Support Scanner or Lexer or Parser as public API

• Support Anchor and Alias to Marshaler

• Allow referencing elements declared in another file via anchors

• Extract value or AST by YAMLPath (YAMLPath is like a JSONPath)

provides a pure Go implementation of Universally Unique Identifiers (UUID) variant as defined in RFC-4122. This package supports the following UUID versions:

Version 1, based on timestamp and MAC address (RFC-4122) Version 3, based on MD5 hashing of a named value (RFC-4122) Version 4, based on random numbers (RFC-4122) Version 5, based on SHA-1 hashing of a named value (RFC-4122)

This package provides a functionality to communicate directly with a Trusted Platform Module device. The libraries don't implement the entire spec for neither 1.2 nor 2.0.

Included submodules:

• tpm - TPM 1.2 client library

• tpm2 - TPM 2.0 client library.

• direct - the prototype "TPMDirect" TPM 2.0 API, which is intended to (eventually) be 1:1 with the TPM 2.0 spec

This package implements HTTP request and response signing and verification. Supports the major MAC and asymmetric key signature algorithms. It has several safety restrictions: One, none of the widely known non-cryptographically safe algorithms are permitted; Two, the RSA SHA256 algorithms must be available in the binary (and it should, barring export restrictions); Finally, the library assumes either the Authorizationn or Signature headers are to be set (but not both).

It's an alternative fork of https://github.com/go-fed/httpsig.

This package implements ULID as specified in https://github.com/ulid/spec.

Features of ULID:

• 128-bit compatibility with UUID

• 1.21e+24 unique ULIDs per millisecond

• lexicographically sortable

• canonically encoded as a 26 character string, as opposed to the 36 character UUID

• uses Crockford's base32 for better efficiency and readability (5 bits per character)

• case insensitive

• no special characters (URL safe)

• monotonic sort order (correctly detects and handles the same millisecond)

libdns is a collection of free-range DNS provider client implementations. It defines the core interfaces that provider packages should implement. They are small and idiomatic interfaces with well-defined semantics.

The interfaces include:

• RecordGetter to list records.

• RecordAppender to append new records.

• RecordSetter to set (create or change existing) records.

• RecordDeleter to delete records.

This Package provides a functionality of INI file read and write, implementing features:

• load from multiple data sources(file, []byte, io.Reader and io.ReadCloser) with overwrites

• read with recursion values

• read with parent-child sections

• read with auto-increment key names

• read with multiple-line values

• read with tons of helper methods

• read and convert values to Go types

• read and WRITE comments of sections and keys

• manipulate sections, keys and comments with ease

• keep sections and keys in order as you parse and save

cli is a library for implementing command-line interfaces. Features:

• easy sub-command based CLIs: cli foo, cli bar, etc.

• support for nested subcommands such as cli foo bar

• optional support for default subcommands so cli does something other than error

• support for shell autocompletion of subcommands, flags, and arguments with callbacks in Go

• automatic help generation for listing subcommands

• automatic help flag recognition of -h, --help, etc.

• automatic version flag recognition of -v, --version

• helpers for interacting with the terminal, such as outputting information, asking for input, etc.

• use of Go interfaces/types makes augmenting various parts of the library a piece of cake

Simplistic, opinionated logging for Golang.

This package provides a reflection extension.

Collection of compression libraries for Go

Package pdf implements reading of PDF files.

Package gozstd is Go wrapper for zstd.

Package json5 implements decoding of JSON5 values.

refmt is a serialization and object-mapping library.

This package provides a simple ASCII tree composing tool.