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.

pkcs8 implements functions to process private keys in PKCS#8 format, as defined in RFC 5208 and RFC 5958. It can handle both unencrypted PKCS#8 PrivateKeyInfo format and EncryptedPrivateKeyInfo format with PKCS#5 (v2.0) algorithms.

go-github-com-gosuri-uilive go library for updating terminal output in realtime. It provides a buffered io.Writer that is flushed at a timed interval. go-github-com-gosuri-uilive powers go-github-com-gosuri-uiprogress.

This package is an enhanced version of the golang.org/x/image/tiff library featuring:

• Read support for CCITT Group3/4 compressed images.

• Read/write support for LZW compressed images.

• Read/write support for the CMYK color model.

The gruid module provides packages for easily building grid-based applications in Go. The library abstracts rendering and input for different platforms. There are drivers available for terminal apps, native graphical apps and browser apps. The original application for the library was creating grid-based games, but it's also well suited for any grid-based application.

A mini testing helper for Go.

• It has a simple interface (is.OK and is.Equal).

• It plugs into existing Go toolchain (uses testing.T).

• It's obvious for newcomers.

• It also gives you is.Panic and is.PanicWith helpers - because testing panics is ugly.

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).

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)

DOM is a Go package for manipulating @urlhttps://godoc.org/golang.org/x/net/html,HTML node. The methods that exist in this package has similar name and purpose as the DOM manipulation methods in JS, which make it useful when porting code from JS to Go. Currently it used in @urlhttps://github.com/go-shiori/warc,(code warc) and @urlhttps://github.com/go-shiori/go-readability,(code go-readability).

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

The @codegoxpp library is an XML parser library that is loosely based on the @urlhttp://www.xmlpull.org/v1/download/unpacked/doc/quick_intro.html,Java XMLPullParser. This library allows you to easily parse arbitrary XML content using a pull parser. You can think of @codegoxpp as a lightweight wrapper around Go's XML @codeDecoder that provides a set of functions that make it easier to parse XML content than using the raw decoder itself.

This package implements ULID as specificed 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)

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

This package provides Gin Web Framework written in Golang. It has a list of higliths comparting to similar Martini Web Framework:

• Fast :: Radix tree based routing, small memory foot print. No reflection. Predictable API performance.

• Middleware support :: An incoming HTTP request can be handled by a chain of middleware and the final action. For example: Logger, Authorization, GZIP and finally post a message in the DB.

• Crash-free :: Gin can catch a panic occurred during a HTTP request and recover it. This way, your server will be always available. It’s also possible to report this panic to Sentry for example!

• JSON validation :: Gin can parse and validate the JSON of a request, checking, for example, the existence of required values.

• Routes grouping :: Organize your routes better. Authorization required vs non required, different API versions. In addition, groups can be nested infinitely without degrading performance.

• Error management :: Gin provides a convenient way to collect all the errors occurred during a HTTP request. Eventually, middleware can write them to a log file, to a database and send them through the network.

• Rendering built-in :: Gin provides an easy to use API for JSON, XML and HTML rendering.

Simplistic, opinionated logging for Golang.

Collection of compression libraries for Go

Package errors provides simple error handling primitives.